@agentscope-ai/chat 1.1.39 → 1.1.41-beta.1764749089549

package/lib/Markdown/Markdown/hooks/useStreaming.js

@@ -1,521 +0,0 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { 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 _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-var TokenType = /*#__PURE__*/function (TokenType) {
-  TokenType[TokenType["Text"] = 0] = "Text";
-  TokenType[TokenType["Link"] = 1] = "Link";
-  TokenType[TokenType["Image"] = 2] = "Image";
-  TokenType[TokenType["Heading"] = 3] = "Heading";
-  TokenType[TokenType["MaybeEmphasis"] = 4] = "MaybeEmphasis";
-  TokenType[TokenType["Emphasis"] = 5] = "Emphasis";
-  TokenType[TokenType["Strong"] = 6] = "Strong";
-  TokenType[TokenType["XML"] = 7] = "XML";
-  TokenType[TokenType["MaybeCode"] = 8] = "MaybeCode";
-  TokenType[TokenType["Code"] = 9] = "Code";
-  TokenType[TokenType["MaybeHr"] = 10] = "MaybeHr";
-  TokenType[TokenType["MaybeList"] = 11] = "MaybeList";
-  TokenType[TokenType["MaybeInlineMath"] = 12] = "MaybeInlineMath";
-  TokenType[TokenType["InlineMath"] = 13] = "InlineMath";
-  TokenType[TokenType["MaybeBlockMath"] = 14] = "MaybeBlockMath";
-  TokenType[TokenType["BlockMath"] = 15] = "BlockMath";
-  TokenType[TokenType["MaybeBackslashMath"] = 16] = "MaybeBackslashMath";
-  TokenType[TokenType["Word"] = 17] = "Word";
-  return TokenType;
-}(TokenType || {});
-var Markdown_Symbols = {
-  emphasis: ['*', '_'],
-  code: ['`'],
-  list: ['-', '+', '*']
-};
-
-// 辅助函数：判断是否是英文字母
-var isEnglishLetter = function isEnglishLetter(char) {
-  var code = char.charCodeAt(0);
-  return code >= 65 && code <= 90 || code >= 97 && code <= 122; // A-Z or a-z
-};
-
-// 辅助函数：判断是否是单词的一部分（字母、数字、连字符、撇号）
-var isWordChar = function isWordChar(char) {
-  var code = char.charCodeAt(0);
-  return code >= 65 && code <= 90 ||
-  // A-Z
-  code >= 97 && code <= 122 ||
-  // a-z
-  code >= 48 && code <= 57 ||
-  // 0-9
-  char === '-' ||
-  // 连字符 (well-known)
-  char === "'" // 撇号 (don't)
-  ;
-};
-
-// 辅助函数：判断是否是单词分隔符
-var isWordSeparator = function isWordSeparator(char) {
-  return char === ' ' || char === '\n' || char === '\t' || char === ',' || char === '.' || char === '!' || char === '?' || char === ';' || char === ':' || char === ')' || char === ']' || char === '}' || char === '"' || char === "'" || char === '>' || char === '<';
-};
-var STREAM_BUFFER_INIT = {
-  processedLength: 0,
-  rawStream: '',
-  pending: '',
-  token: TokenType.Text,
-  tokens: [TokenType.Text],
-  headingLevel: 0,
-  emphasisCount: 0,
-  backtickCount: 0,
-  dollarCount: 0,
-  mathDelimiter: '',
-  blockMathEnding: false // 标记是否遇到了结束的 $$
-};
-var useStreaming = function useStreaming(input, config, cursor) {
-  var _ref = config || {},
-    _ref$hasNextChunk = _ref.hasNextChunk,
-    hasNextChunk = _ref$hasNextChunk === void 0 ? false : _ref$hasNextChunk,
-    _ref$enableWordCachin = _ref.enableWordCaching,
-    enableWordCaching = _ref$enableWordCachin === void 0 ? false : _ref$enableWordCachin,
-    _ref$enableMathCachin = _ref.enableMathCaching,
-    enableMathCaching = _ref$enableMathCachin === void 0 ? true : _ref$enableMathCachin;
-  var _useState = useState(''),
-    _useState2 = _slicedToArray(_useState, 2),
-    output = _useState2[0],
-    setOutput = _useState2[1];
-  var streamBuffer = useRef(_objectSpread({}, STREAM_BUFFER_INIT));
-  var pushToken = useCallback(function (type) {
-    streamBuffer.current.tokens = [].concat(_toConsumableArray(streamBuffer.current.tokens), [type]);
-    streamBuffer.current.token = type;
-  }, []);
-  var popToken = useCallback(function () {
-    var tokens = streamBuffer.current.tokens;
-    if (tokens.length <= 1) return;
-    var newTokens = _toConsumableArray(tokens.slice(0, -1));
-    streamBuffer.current.tokens = newTokens;
-    streamBuffer.current.token = newTokens[newTokens.length - 1];
-  }, []);
-  var flushOutput = function flushOutput() {
-    var needPopToken = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    if (needPopToken) popToken();
-    streamBuffer.current.pending = '';
-    streamBuffer.current.blockMathEnding = false;
-    var renderText = streamBuffer.current.rawStream;
-    if (renderText) {
-      setOutput(renderText);
-    }
-  };
-  var handleChunk = function handleChunk(chunk) {
-    var buffer = streamBuffer.current;
-    var _iterator = _createForOfIteratorHelper(chunk),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var char = _step.value;
-        buffer.rawStream += char;
-        buffer.pending += char;
-        var token = buffer.token,
-          pending = buffer.pending,
-          tokens = buffer.tokens,
-          emphasisCount = buffer.emphasisCount;
-        switch (token) {
-          case TokenType.Image:
-            {
-              /**
-               * \![
-               *   ^
-               */
-              var isInvalidStart = pending.indexOf('![') === -1;
-              /**
-               * \![image]()
-               *           ^
-               */
-              var isImageEnd = char === ')' || char === '\n';
-              if (isInvalidStart || isImageEnd) {
-                if (tokens[tokens.length - 2] === TokenType.Link) {
-                  popToken();
-                } else {
-                  flushOutput();
-                }
-              }
-              break;
-            }
-          case TokenType.Link:
-            {
-              // not support link reference definitions, [foo]: /url "title" \n[foo]
-              var isReferenceLink = pending.endsWith(']:');
-              var isLinkEnd = char === ')' || char === '\n';
-              var isImageInLink = char === '!';
-              if (isImageInLink) {
-                pushToken(TokenType.Image);
-              } else if (isLinkEnd || isReferenceLink) {
-                flushOutput();
-              }
-              break;
-            }
-          case TokenType.Heading:
-            {
-              /**
-               * # token / ## token / #####token
-               *  ^         ^              ^
-               */
-              buffer.headingLevel++;
-              var shouldFlushOutput = char !== '#' || buffer.headingLevel >= 6;
-              if (shouldFlushOutput) {
-                flushOutput();
-                buffer.headingLevel = 0;
-              }
-              break;
-            }
-          case TokenType.MaybeEmphasis:
-            {
-              /**
-                 * /* / *\/n
-                    ^     ^
-                 */
-              var _shouldFlushOutput = char === ' ' || char === '\n';
-              if (_shouldFlushOutput) {
-                flushOutput();
-              } else if (Markdown_Symbols.emphasis.includes(char)) {
-                buffer.emphasisCount++;
-              } else {
-                popToken();
-                if (emphasisCount === 1) {
-                  /**
-                   * _token_ / *token*
-                   * ^         ^
-                   */
-                  pushToken(TokenType.Emphasis);
-                } else if (emphasisCount === 2) {
-                  /**
-                   * __token__ / **token**
-                   *  ^           ^
-                   */
-                  pushToken(TokenType.Strong);
-                } else if (emphasisCount === 3) {
-                  /**
-                   * ___token___ / ***token***
-                   *   ^             ^
-                   */
-                  pushToken(TokenType.Emphasis);
-                  pushToken(TokenType.Strong);
-                } else {
-                  // no more than 3
-                  buffer.emphasisCount = 0;
-                }
-              }
-              break;
-            }
-          case TokenType.Strong:
-            {
-              /**
-               * __token__ / **token**
-               *         ^           ^
-               */
-              if (char === '\n') {
-                flushOutput();
-              } else if (pending.endsWith('**') || pending.endsWith('__')) {
-                if (tokens[tokens.length - 2] === TokenType.Emphasis) {
-                  popToken();
-                } else {
-                  flushOutput();
-                }
-              }
-              break;
-            }
-          case TokenType.Emphasis:
-            {
-              /**
-               * _token_ / *token*
-               *       ^         ^
-               */
-              if (char === '\n') {
-                flushOutput();
-                buffer.emphasisCount = 0;
-              } else if (Markdown_Symbols.emphasis.includes(char)) {
-                flushOutput();
-                buffer.emphasisCount = 0;
-              }
-              break;
-            }
-          case TokenType.XML:
-            {
-              /**
-               * <XML /> /<XML></XML>
-               *       ^      ^
-               */
-              var _shouldFlushOutput2 = char === '>' || pending === '< ' || char === '\n';
-              if (_shouldFlushOutput2) {
-                flushOutput();
-                continue;
-              }
-              break;
-            }
-          case TokenType.MaybeCode:
-            {
-              if (char === '`') {
-                buffer.backtickCount++;
-              } else {
-                if (buffer.backtickCount > 2) {
-                  /**
-                   * ```
-                   *   ^
-                   */
-                  flushOutput();
-                  buffer.backtickCount = 0;
-                } else {
-                  /**
-                   * ``
-                   *  ^
-                   */
-                  popToken();
-                  pushToken(TokenType.Code);
-                }
-              }
-              break;
-            }
-          case TokenType.Code:
-            {
-              if (char === '`') {
-                buffer.backtickCount--;
-              }
-              if (buffer.backtickCount === 0) {
-                flushOutput();
-                buffer.backtickCount = 0;
-              }
-              break;
-            }
-          case TokenType.MaybeHr:
-            {
-              if (char !== '-' && char !== '=') {
-                flushOutput();
-              }
-              break;
-            }
-          case TokenType.MaybeList:
-            {
-              if (char !== ' ') {
-                flushOutput();
-              }
-              break;
-            }
-          case TokenType.MaybeInlineMath:
-            {
-              /**
-               * $ / $$
-               * ^    ^
-               */
-              if (char === '$') {
-                buffer.dollarCount++;
-                if (buffer.dollarCount === 2) {
-                  // $$ 块级公式
-                  popToken();
-                  pushToken(TokenType.MaybeBlockMath);
-                  buffer.mathDelimiter = '$$';
-                }
-              } else if (char === '\n') {
-                // $ 后跟换行，不是有效的公式
-                flushOutput();
-                buffer.dollarCount = 0;
-                buffer.mathDelimiter = '';
-              } else {
-                // 确认为行内公式
-                popToken();
-                pushToken(TokenType.InlineMath);
-                buffer.mathDelimiter = '$';
-              }
-              break;
-            }
-          case TokenType.InlineMath:
-            {
-              /**
-               * $x^2$ / \(x^2\)
-               *     ^         ^
-               */
-              if (buffer.mathDelimiter === '$') {
-                if (char === '$') {
-                  flushOutput();
-                  buffer.dollarCount = 0;
-                  buffer.mathDelimiter = '';
-                } else if (char === '\n') {
-                  // 行内公式不应跨行
-                  flushOutput();
-                  buffer.dollarCount = 0;
-                  buffer.mathDelimiter = '';
-                }
-              } else if (buffer.mathDelimiter === '\\(') {
-                if (pending.endsWith('\\)')) {
-                  flushOutput();
-                  buffer.mathDelimiter = '';
-                }
-              }
-              break;
-            }
-          case TokenType.MaybeBlockMath:
-            {
-              /**
-               * $$
-               *   ^
-               */
-              if (char !== '$') {
-                // $$ 后跟任何非 $ 字符，确认为块级公式
-                popToken();
-                pushToken(TokenType.BlockMath);
-              }
-              break;
-            }
-          case TokenType.BlockMath:
-            {
-              /**
-               * $$E=mc^2$$
-               *         ^^
-               */
-              // 处理 $$ 块级公式
-              if (buffer.mathDelimiter === '$$') {
-                // 检测是否遇到结束的 $$
-                if (char === '$') {
-                  buffer.dollarCount++;
-                  if (buffer.dollarCount === 2) {
-                    // 遇到了结束 $$，立即释放缓存
-                    flushOutput();
-                    buffer.dollarCount = 0;
-                    buffer.mathDelimiter = '';
-                  }
-                } else {
-                  buffer.dollarCount = 0;
-                }
-              } else if (buffer.mathDelimiter === '\\[') {
-                // 处理 \[...\] 块级公式
-                if (pending.endsWith('\\]')) {
-                  flushOutput();
-                  buffer.mathDelimiter = '';
-                }
-              }
-              break;
-            }
-          case TokenType.MaybeBackslashMath:
-            {
-              /**
-               * \( / \[
-               *  ^    ^
-               */
-              if (char === '(') {
-                // \( 行内公式
-                popToken();
-                pushToken(TokenType.InlineMath);
-                buffer.mathDelimiter = '\\(';
-              } else if (char === '[') {
-                // \[ 块级公式
-                popToken();
-                pushToken(TokenType.BlockMath);
-                buffer.mathDelimiter = '\\[';
-              } else {
-                // 不是数学公式，普通反斜杠
-                flushOutput();
-                buffer.mathDelimiter = '';
-              }
-              break;
-            }
-          case TokenType.Word:
-            {
-              /**
-               * Hello world
-               *      ^
-               * 缓存英文单词，直到遇到分隔符（空格、标点等）
-               */
-              if (isWordSeparator(char)) {
-                // 遇到分隔符，释放缓存显示完整单词
-                flushOutput();
-              } else if (!isWordChar(char)) {
-                // 遇到非单词字符且非分隔符（如 Markdown 符号），也释放缓存
-                flushOutput();
-              }
-              // 否则继续缓存单词字符
-              break;
-            }
-          default:
-            {
-              buffer.pending = char;
-              if (char === '!') {
-                pushToken(TokenType.Image);
-              } else if (char === '[') {
-                pushToken(TokenType.Link);
-              } else if (char === '#') {
-                pushToken(TokenType.Heading);
-              } else if (char === '_' || char === '*') {
-                pushToken(TokenType.MaybeEmphasis);
-                buffer.emphasisCount = 1;
-              } else if (char === '<') {
-                pushToken(TokenType.XML);
-              } else if (char === '`') {
-                pushToken(TokenType.MaybeCode);
-                buffer.backtickCount = 1;
-              } else if (char === '-' || char === '=') {
-                pushToken(TokenType.MaybeHr);
-              } else if (Markdown_Symbols.list.includes(char)) {
-                pushToken(TokenType.MaybeList);
-              } else if (enableMathCaching && char === '$') {
-                // 只有启用公式缓存时，才缓存 $ 符号的公式
-                pushToken(TokenType.MaybeInlineMath);
-                buffer.dollarCount = 1;
-                buffer.mathDelimiter = '';
-              } else if (enableMathCaching && char === '\\') {
-                // 只有启用公式缓存时，才缓存 \ 开头的公式
-                pushToken(TokenType.MaybeBackslashMath);
-              } else if (enableWordCaching && isEnglishLetter(char)) {
-                // 只有启用单词缓存时，才缓存英文单词
-                pushToken(TokenType.Word);
-              } else {
-                flushOutput(false);
-              }
-            }
-        }
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-  };
-  var cursorContent = useMemo(function () {
-    if (config !== null && config !== void 0 && config.enableAnimation) return '';
-    if (cursor) {
-      if (cursor === 'dot') return ' :dot:';
-      if (cursor === 'underline') return ' :underline:';
-      return ' :dot:';
-    }
-    return '';
-  }, [cursor]);
-  useEffect(function () {
-    if (!input) {
-      setOutput('');
-      streamBuffer.current = _objectSpread({}, STREAM_BUFFER_INIT);
-      return;
-    }
-    if (typeof input !== 'string') {
-      console.error("X-Markdown: input must be string, not ".concat(_typeof(input), "."));
-      return;
-    }
-    if (!hasNextChunk) {
-      setOutput(input);
-      return;
-    }
-    var chunk = input.slice(streamBuffer.current.processedLength);
-    if (chunk.length) {
-      streamBuffer.current.processedLength += chunk.length;
-      handleChunk(chunk);
-    }
-  }, [input, hasNextChunk]);
-  return output + cursorContent;
-};
-export default useStreaming;

package/lib/Markdown/Markdown/hooks/useTyping.d.ts

@@ -1,4 +0,0 @@
-export declare const useTyping: ({ content, typing }: {
-    content: any;
-    typing: any;
-}) => any;

package/lib/Markdown/Markdown/index.d.ts

@@ -1,84 +0,0 @@
-/// <reference types="react" />
-import type { MarkdownProps as InnerMarkdownProps } from './interface';
-export interface MarkdownProps {
-    /**
-     * @description 需要渲染的 Markdown 内容
-     * @descriptionEn Markdown content to be rendered
-     */
-    content?: InnerMarkdownProps['content'];
-    /**
-     * @description 光标样式类型，支持点状、下划线或布尔值控制
-     * @descriptionEn Cursor style type, supports dot, underline, or boolean control
-     */
-    cursor?: boolean | 'dot' | 'underline';
-    /**
-     * @description 基础字体大小，影响整个Markdown内容的字体大小
-     * @descriptionEn Base font size that affects the font size of the entire Markdown content
-     */
-    baseFontSize?: InnerMarkdownProps['baseFontSize'];
-    /**
-     * @description 基础行高，影响文本的行间距
-     * @descriptionEn Base line height that affects text line spacing
-     */
-    baseLineHeight?: InnerMarkdownProps['baseLineHeight'];
-    /**
-     * @description 引用数据数组，用于显示引用信息
-     * @descriptionEn Citation data array for displaying reference information
-     */
-    citations?: InnerMarkdownProps['citations'];
-    /**
-     * @description 引用映射对象，用于快速查找引用信息
-     * @descriptionEn Citation mapping object for quick lookup of reference information
-     */
-    citationsMap?: InnerMarkdownProps['citationsMap'];
-    /**
-     * @description 用于替换 HTML 元素的自定义 React 组件映射，组件会接收 domNode、streamStatus 等属性
-     * @descriptionEn Custom React components to replace HTML elements, components receive domNode, streamStatus, etc.
-     */
-    components?: InnerMarkdownProps['components'];
-    /**
-     * @description 是否允许渲染HTML标签，影响安全性
-     * @descriptionEn Whether to allow rendering HTML tags, affects security
-     */
-    allowHtml?: boolean;
-    /**
-     * @description 是否禁用图片渲染
-     * @descriptionEn Whether to disable image rendering
-     */
-    disableImage?: boolean;
-    /**
-     * @description 是否启用打字机效果，逐字显示内容
-     * @descriptionEn Whether to enable typewriter effect for character-by-character display
-     */
-    typing?: boolean | number;
-    /**
-     * @description 是否以原始文本形式显示，跳过Markdown解析
-     * @descriptionEn Whether to display as raw text, skipping Markdown parsing
-     */
-    raw?: boolean;
-    /**
-     * @description 组件的CSS类名
-     * @descriptionEn CSS class name for the component
-     */
-    className?: string;
-    /**
-     * @description 启用英文单词缓存，单词会在遇到空格或标点后才整体显示（仅在 typing 为 true 时生效）
-     * @descriptionEn Enable English word caching, words will be displayed as a whole after encountering spaces or punctuation (only works when typing is true)
-     * @default false
-     */
-    enableWordCaching?: boolean;
-    /**
-     * @description 启用 LaTeX 公式缓存，公式会在完整后才整体显示（仅在 typing 为 true 时生效）
-     * @descriptionEn Enable LaTeX formula caching, formulas will be displayed as a whole when complete (only works when typing is true)
-     * @default true
-     */
-    enableMathCaching?: boolean;
-    /**
-     * @description 启用文字出现动画效果
-     * @descriptionEn Enable text appearance animation effects
-     * @default false
-     */
-    enableAnimation?: boolean;
-}
-declare const _default: import("react").NamedExoticComponent<MarkdownProps>;
-export default _default;