@king-design/vue 3.7.0 → 3.8.0-beta.0

package/components/xmarkdown/markdown/streaming.js

@@ -0,0 +1,513 @@
+import _Array$from from "@babel/runtime-corejs3/core-js/array/from";
+import _Symbol from "@babel/runtime-corejs3/core-js/symbol";
+import _getIteratorMethod from "@babel/runtime-corejs3/core-js/get-iterator-method";
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof _Symbol !== "undefined" && _getIteratorMethod(o) || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { var _context12; if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = _sliceInstanceProperty(_context12 = Object.prototype.toString.call(o)).call(_context12, 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; }
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js/instance/includes";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/slice";
+import _startsWithInstanceProperty from "@babel/runtime-corejs3/core-js/instance/starts-with";
+import _trimInstanceProperty from "@babel/runtime-corejs3/core-js/instance/trim";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js/instance/filter";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js/instance/map";
+import _endsWithInstanceProperty from "@babel/runtime-corejs3/core-js/instance/ends-with";
+/**
+ * 流式渲染
+ */
+import { _$ } from '../../../i18n';
+import { escapeHtml } from './utils';
+import { createElementNode, createKeyGenerator, createTextNode, renderTreeNodes } from './renderTree';
+var STREAM_INCOMPLETE_REGEX = {
+  image: [/^!\[[^\]\r\n]{0,1000}$/, /^!\[[^\r\n]{0,1000}\]\(*[^)\r\n]{0,1000}$/],
+  link: [/^\[[^\]\r\n]{0,1000}$/, /^\[[^\r\n]{0,1000}\]\(*[^)\r\n]{0,1000}$/],
+  html: [/^<\/$/, /^<\/?[a-zA-Z][a-zA-Z0-9-]{0,100}[^>\r\n]{0,1000}$/],
+  emphasis: [/^(\*{1,3}|_{1,3})(?!\s)(?!.*\1$)[^\r\n]{0,1000}$/],
+  list: [/^[-+*]\s{0,3}$/, /^[-+*]\s{1,3}(\*{1,3}|_{1,3})(?!\s)(?!.*\1$)[^\r\n]{0,1000}$/],
+  'inline-code': [/^`[^`\r\n]{0,300}$/]
+};
+/**
+ * 创建流式尾部缓存
+ */
+export function createStreamingTailCache() {
+  return {
+    processedLength: 0,
+    completeMarkdown: '',
+    pending: '',
+    token: 'text'
+  };
+}
+/**
+ * 判断源码中是否包含公式语法
+ */
+export function containsFormulaSyntax(source, delimiters) {
+  if (!source) return false;
+  var activeDelimiters = Array.isArray(delimiters) ? delimiters : delimiters ? [delimiters] : ['dollars', 'beg_end'];
+  if (_includesInstanceProperty(activeDelimiters).call(activeDelimiters, 'dollars') && /(^|[^\\])\${1,2}[\s\S]+?(^|[^\\])\${1,2}/.test(source)) {
+    return true;
+  }
+  if (_includesInstanceProperty(activeDelimiters).call(activeDelimiters, 'beg_end') && /\\begin\{[\s\S]+?\\end\{/.test(source)) {
+    return true;
+  }
+  if (_includesInstanceProperty(activeDelimiters).call(activeDelimiters, 'brackets') && /\\\[[\s\S]+?\\\]/.test(source)) {
+    return true;
+  }
+  return false;
+}
+/**
+ * 将流式 Markdown 拆分为 stable 和 tail 两段
+ */
+export function splitMarkdownForStreaming(source, cache) {
+  var normalized = (source || '').replace(/\r\n?/g, '\n');
+  if (!normalized) {
+    resetCache(cache);
+    return {
+      stableSource: '',
+      tailText: '',
+      openFence: null
+    };
+  }
+  var openFence = findOpenFence(normalized);
+  if (openFence) {
+    resetCache(cache);
+    var tailText = _sliceInstanceProperty(normalized).call(normalized, openFence.start);
+    var language = extractLanguageFromFence(tailText);
+    return {
+      stableSource: _sliceInstanceProperty(normalized).call(normalized, 0, openFence.start),
+      tailText: tailText,
+      openFence: _extends({}, openFence, {
+        language: language
+      })
+    };
+  }
+  var openMathBlock = findOpenMathBlock(normalized);
+  if (openMathBlock) {
+    resetCache(cache);
+    return {
+      stableSource: _sliceInstanceProperty(normalized).call(normalized, 0, openMathBlock.start),
+      tailText: _sliceInstanceProperty(normalized).call(normalized, openMathBlock.start),
+      openFence: null
+    };
+  }
+  var inlineTail = resolveInlineStreamingTail(normalized, cache);
+  if (inlineTail.tailText) {
+    return {
+      stableSource: inlineTail.stableSource,
+      tailText: inlineTail.tailText,
+      openFence: null
+    };
+  }
+  var trailingBlock = findTrailingIncompleteBlock(normalized);
+  if (trailingBlock) {
+    resetCache(cache);
+    return {
+      stableSource: _sliceInstanceProperty(normalized).call(normalized, 0, trailingBlock.start),
+      tailText: _sliceInstanceProperty(normalized).call(normalized, trailingBlock.start),
+      openFence: null
+    };
+  }
+  return {
+    stableSource: normalized,
+    tailText: '',
+    openFence: null
+  };
+}
+/**
+ * 渲染尚未进入 stable 区的尾部内容
+ */
+export function renderMarkdownTail(tailText, openFence, options) {
+  if (openFence === void 0) {
+    openFence = null;
+  }
+  if (options === void 0) {
+    options = {};
+  }
+  if (!tailText) return [];
+  var nextKey = createKeyGenerator('xmarkdown-tail');
+  var prefixCls = options.prefixCls || 'k';
+  if (openFence) {
+    return renderTreeNodes([renderOpenCodeBlock(tailText, openFence, prefixCls, nextKey)], options);
+  }
+  var children = [];
+  tailText.split('\n').forEach(function (line, index, lines) {
+    children.push(createTextNode(line));
+    if (index < lines.length - 1) {
+      children.push(createElementNode('br', {}, [], nextKey('br')));
+    }
+  });
+  return renderTreeNodes([createElementNode('span', {
+    'data-kpc-xmarkdown-tail': 'true'
+  }, children, nextKey('tail'))], options);
+}
+/**
+ * 转义 tail 中的 HTML 文本
+ */
+export function escapeMarkdownHtml(text) {
+  return escapeHtml(text);
+}
+/**
+ * 识别 inline 级别的未完成 token
+ */
+function resolveInlineStreamingTail(source, cache) {
+  if (cache === void 0) {
+    cache = createStreamingTailCache();
+  }
+  var expectedPrefix = cache.completeMarkdown + cache.pending;
+  if (!_startsWithInstanceProperty(source).call(source, expectedPrefix)) {
+    resetCache(cache);
+  }
+  var chunk = _sliceInstanceProperty(source).call(source, cache.processedLength);
+  if (chunk) {
+    cache.processedLength += chunk.length;
+    for (var _iterator = _createForOfIteratorHelperLoose(chunk), _step; !(_step = _iterator()).done;) {
+      var char = _step.value;
+      cache.pending += char;
+      recognizeToken(cache);
+      if (cache.token === 'text') {
+        commitCache(cache);
+      }
+    }
+  }
+  var tailText = getPendingTail(cache);
+  return {
+    stableSource: cache.completeMarkdown,
+    tailText: tailText
+  };
+}
+/**
+ * 更新当前缓存中的 token 状态
+ */
+function recognizeToken(cache) {
+  if (cache.token === 'text') {
+    var _context, _context2, _context3, _context4, _context5, _context6, _context7;
+    if (_startsWithInstanceProperty(_context = cache.pending).call(_context, '!')) {
+      cache.token = 'image';
+      if (!isStreamingValid(cache.token, cache.pending)) {
+        cache.token = 'text';
+      }
+      return;
+    }
+    if (_startsWithInstanceProperty(_context2 = cache.pending).call(_context2, '[')) {
+      cache.token = 'link';
+      return;
+    }
+    if (_startsWithInstanceProperty(_context3 = cache.pending).call(_context3, '<')) {
+      cache.token = 'html';
+      return;
+    }
+    if (_startsWithInstanceProperty(_context4 = cache.pending).call(_context4, '*') || _startsWithInstanceProperty(_context5 = cache.pending).call(_context5, '_')) {
+      cache.token = 'emphasis';
+      return;
+    }
+    if (/^[-+*]/.test(cache.pending)) {
+      cache.token = 'list';
+      return;
+    }
+    if (_startsWithInstanceProperty(_context6 = cache.pending).call(_context6, '|')) {
+      cache.token = 'table';
+      return;
+    }
+    if (_startsWithInstanceProperty(_context7 = cache.pending).call(_context7, '`')) {
+      cache.token = 'inline-code';
+    }
+    return;
+  }
+  if (cache.token === 'list') {
+    var commitPrefix = getListCommitPrefix(cache.pending);
+    if (commitPrefix) {
+      var _context8;
+      cache.completeMarkdown += commitPrefix;
+      cache.pending = _sliceInstanceProperty(_context8 = cache.pending).call(_context8, commitPrefix.length);
+      cache.token = 'text';
+      recognizeToken(cache);
+      return;
+    }
+  }
+  if (!isStreamingValid(cache.token, cache.pending)) {
+    cache.token = 'text';
+  }
+}
+/**
+ * 提交当前已确认稳定的缓存内容
+ */
+function commitCache(cache) {
+  if (cache.pending) {
+    cache.completeMarkdown += cache.pending;
+    cache.pending = '';
+  }
+  cache.token = 'text';
+}
+/**
+ * 获取仍需保留在 tail 中的内容
+ */
+function getPendingTail(cache) {
+  if (!cache.pending || cache.token === 'text') {
+    return '';
+  }
+  if (cache.token === 'image' && cache.pending === '!') {
+    return '';
+  }
+  if (cache.token === 'table' && cache.pending.split('\n').length > 2) {
+    commitCache(cache);
+    return '';
+  }
+  return cache.pending;
+}
+/**
+ * 重置流式尾部缓存
+ */
+function resetCache(cache) {
+  if (!cache) return;
+  cache.processedLength = 0;
+  cache.completeMarkdown = '';
+  cache.pending = '';
+  cache.token = 'text';
+}
+/**
+ * 判断 pending 内容是否仍是未完成 token
+ */
+function isStreamingValid(token, pending) {
+  switch (token) {
+    case 'link':
+      return STREAM_INCOMPLETE_REGEX.link.some(function (re) {
+        return re.test(pending);
+      });
+    case 'image':
+      return STREAM_INCOMPLETE_REGEX.image.some(function (re) {
+        return re.test(pending);
+      });
+    case 'html':
+      return STREAM_INCOMPLETE_REGEX.html.some(function (re) {
+        return re.test(pending);
+      });
+    case 'emphasis':
+      return STREAM_INCOMPLETE_REGEX.emphasis.some(function (re) {
+        return re.test(pending);
+      });
+    case 'list':
+      return STREAM_INCOMPLETE_REGEX.list.some(function (re) {
+        return re.test(pending);
+      });
+    case 'table':
+      return isTableIncomplete(pending);
+    case 'inline-code':
+      return STREAM_INCOMPLETE_REGEX['inline-code'].some(function (re) {
+        return re.test(pending);
+      });
+    default:
+      return false;
+  }
+}
+/**
+ * 判断当前表格片段是否仍未闭合
+ */
+function isTableIncomplete(markdown) {
+  var _context9, _context10;
+  if (_includesInstanceProperty(markdown).call(markdown, '\n\n')) return false;
+  var lines = markdown.split('\n');
+  if (lines.length <= 1) return true;
+  var header = lines[0],
+    separator = lines[1];
+  if (!/^\|.*\|$/.test(_trimInstanceProperty(header).call(header))) return false;
+  var columns = _filterInstanceProperty(_context9 = _mapInstanceProperty(_context10 = _trimInstanceProperty(separator).call(separator).split('|')).call(_context10, function (column) {
+    return _trimInstanceProperty(column).call(column);
+  })).call(_context9, Boolean);
+  var separatorRegex = /^:?-+:?$/;
+  return columns.every(function (column, index) {
+    return index === columns.length - 1 ? column === ':' || separatorRegex.test(column) : separatorRegex.test(column);
+  });
+}
+/**
+ * 识别列表前缀中可提前提交的部分
+ */
+function getListCommitPrefix(pending) {
+  var _pending$match;
+  var listPrefix = (_pending$match = pending.match(/^([-+*]\s{0,3})/)) == null ? void 0 : _pending$match[1];
+  var rest = listPrefix ? _sliceInstanceProperty(pending).call(pending, listPrefix.length) : '';
+  return listPrefix && _startsWithInstanceProperty(rest).call(rest, '`') ? listPrefix : null;
+}
+/**
+ * 查找未闭合的代码围栏
+ */
+function findOpenFence(source) {
+  var lineStart = 0;
+  var openFence = null;
+  while (lineStart <= source.length) {
+    var lineEnd = source.indexOf('\n', lineStart);
+    var nextLineStart = lineEnd === -1 ? source.length + 1 : lineEnd + 1;
+    var line = lineEnd === -1 ? _sliceInstanceProperty(source).call(source, lineStart) : _sliceInstanceProperty(source).call(source, lineStart, lineEnd);
+    var match = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (match) {
+      var marker = match[1].charAt(0);
+      var size = match[1].length;
+      if (!openFence) {
+        openFence = {
+          marker: marker,
+          size: size,
+          start: lineStart
+        };
+      } else if (openFence.marker === marker && size >= openFence.size) {
+        openFence = null;
+      }
+    }
+    if (lineEnd === -1) break;
+    lineStart = nextLineStart;
+  }
+  return openFence;
+}
+/**
+ * 查找未闭合的块级公式
+ */
+function findOpenMathBlock(source) {
+  var lines = source.split('\n');
+  var inMathBlock = false;
+  var mathBlockStart = -1;
+  var currentPos = 0;
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    var lineTrimmed = _trimInstanceProperty(line).call(line);
+    if (lineTrimmed === '$$') {
+      if (!inMathBlock) {
+        inMathBlock = true;
+        mathBlockStart = currentPos + line.indexOf('$$');
+      } else {
+        inMathBlock = false;
+        mathBlockStart = -1;
+      }
+    }
+    currentPos += line.length + 1;
+  }
+  if (inMathBlock && mathBlockStart >= 0) {
+    return {
+      start: mathBlockStart
+    };
+  }
+  return null;
+}
+/**
+ * 提取未闭合代码围栏的语言标记
+ */
+function extractLanguageFromFence(tailText) {
+  var _context11;
+  var firstLineEnd = tailText.indexOf('\n');
+  var firstLine = firstLineEnd === -1 ? tailText : _sliceInstanceProperty(tailText).call(tailText, 0, firstLineEnd);
+  var match = firstLine.match(/^ {0,3}`{3,}(\S*)/);
+  return match && match[1] ? _trimInstanceProperty(_context11 = match[1]).call(_context11).toLowerCase() : undefined;
+}
+/**
+ * 渲染未闭合的代码围栏
+ */
+function renderOpenCodeBlock(tailText, openFence, prefixCls, nextKey) {
+  var lines = tailText.split('\n');
+  var language = openFence.language || '';
+  var languageClass = language ? "hljs language-" + language : 'hljs';
+  var languageLabel = language || _$('代码');
+  var codeLines = _sliceInstanceProperty(lines).call(lines, 1).join('\n');
+  return createElementNode('div', {
+    className: prefixCls + "-xmarkdown-code-block",
+    'data-kpc-code-block': 'true',
+    'data-kpc-language': languageLabel,
+    'data-kpc-open-fence': 'true'
+  }, [createElementNode('div', {
+    className: prefixCls + "-xmarkdown-code-toolbar"
+  }, [createElementNode('span', {
+    className: prefixCls + "-xmarkdown-code-language"
+  }, [createTextNode(languageLabel)], nextKey('code-language'))], nextKey('code-toolbar')), createElementNode('div', {
+    className: prefixCls + "-xmarkdown-code-body"
+  }, [createElementNode('pre', {
+    className: 'hljs'
+  }, [createElementNode('code', {
+    className: languageClass
+  }, [createTextNode(codeLines)], nextKey('open-code'))], nextKey('open-pre'))], nextKey('code-body'))], nextKey('open-block'));
+}
+/**
+ * 查找行尾可能尚未完成的块级内容
+ */
+function findTrailingIncompleteBlock(source) {
+  if (!source || _endsWithInstanceProperty(source).call(source, '\n')) return null;
+  var lastNewLineIndex = source.lastIndexOf('\n');
+  var start = lastNewLineIndex === -1 ? 0 : lastNewLineIndex + 1;
+  var line = _sliceInstanceProperty(source).call(source, start);
+  if (/^ {0,3}#{1,6}(?:\s|$)/.test(line)) {
+    return {
+      start: start
+    };
+  }
+  if (hasUnmatchedInlineCode(line)) {
+    return {
+      start: start
+    };
+  }
+  if (hasUnmatchedEmphasis(line)) {
+    return {
+      start: start
+    };
+  }
+  if (hasUnmatchedMath(line)) {
+    return {
+      start: start
+    };
+  }
+  return null;
+}
+/**
+ * 判断行内代码是否未闭合
+ */
+function hasUnmatchedInlineCode(line) {
+  var matches = line.match(/`+/g);
+  if (!matches) return false;
+  return matches.reduce(function (count, value) {
+    return count + value.length;
+  }, 0) % 2 === 1;
+}
+/**
+ * 判断强调语法是否未闭合
+ */
+function hasUnmatchedEmphasis(line) {
+  if (countUnescapedMarkers(line, '**') % 2 === 1) return true;
+  if (countUnescapedMarkers(line, '*') % 2 === 1) return true;
+  if (countUnescapedMarkers(line, '__') % 2 === 1) return true;
+  if (countUnescapedMarkers(line, '_') % 2 === 1) return true;
+  return false;
+}
+/**
+ * 判断行内数学公式是否未闭合
+ */
+function hasUnmatchedMath(line) {
+  var count = 0;
+  for (var i = 0; i < line.length; i++) {
+    if (line.charAt(i) !== '$') continue;
+    if (isEscaped(line, i)) continue;
+    count++;
+    while (i + 1 < line.length && line.charAt(i + 1) === '$') {
+      i++;
+    }
+  }
+  return count % 2 === 1;
+}
+/**
+ * 统计未转义标记的出现次数
+ */
+function countUnescapedMarkers(line, marker) {
+  var count = 0;
+  var markerLength = marker.length;
+  for (var i = 0; i <= line.length - markerLength; i++) {
+    if (_sliceInstanceProperty(line).call(line, i, i + markerLength) !== marker) continue;
+    if (isEscaped(line, i)) continue;
+    if (markerLength === 1 && line.charAt(i + 1) === marker) continue;
+    if (marker === '__' && line.charAt(i + markerLength) === '_') continue;
+    count++;
+    i += markerLength - 1;
+  }
+  return count;
+}
+/**
+ * 判断当前位置是否被转义
+ */
+function isEscaped(line, index) {
+  var backslashCount = 0;
+  for (var i = index - 1; i >= 0 && line.charAt(i) === '\\'; i--) {
+    backslashCount++;
+  }
+  return backslashCount % 2 === 1;
+}

package/components/xmarkdown/markdown/types.d.ts

@@ -0,0 +1,124 @@
+/**
+ * 类型定义
+ *
+ * 集中定义 Markdown 渲染相关的所有类型。
+ */
+import type { XMarkdownRenderTreeNode } from './renderTree';
+/** 数学公式分隔符类型 */
+export type XMarkdownFormulaDelimiter = 'dollars' | 'brackets' | 'doxygen' | 'gitlab' | 'julia' | 'kramdown' | 'beg_end';
+/** Markdown 渲染配置 */
+export interface XMarkdownRenderOptions {
+    prefixCls?: string;
+    allowHtml?: boolean;
+    showCodeHeader?: boolean;
+    enableMermaid?: boolean;
+    enableFormula?: boolean;
+    formulaDelimiters?: XMarkdownFormulaDelimiter | XMarkdownFormulaDelimiter[];
+    formulaMacros?: Record<string, string>;
+    sanitizeOptions?: Record<string, any>;
+    plugins?: XMarkdownPlugin[];
+    tagAttrs?: XMarkdownTagAttrs;
+    tagRenderers?: XMarkdownTagRenderers;
+    codeBlockRenderers?: XMarkdownCodeBlockRenderers;
+    streaming?: boolean;
+    typing?: boolean;
+    formulaRuntime?: XMarkdownFormulaRuntime | null;
+    normalizeRendererOutput?: (value: any) => any;
+}
+/** 数学公式运行时（KaTeX + texmath） */
+export interface XMarkdownFormulaRuntime {
+    katex: any;
+    texmath: any;
+}
+/** 标签属性上下文 */
+export interface XMarkdownTagAttrsContext {
+    tag: string;
+    attrs: Record<string, any>;
+    html: string;
+    textContent: string;
+}
+/** 标签属性获取器 */
+export type XMarkdownTagAttrsGetter = (context: XMarkdownTagAttrsContext) => Record<string, any> | undefined;
+export type XMarkdownTagAttrs = Record<string, Record<string, any> | XMarkdownTagAttrsGetter>;
+/** 标签渲染上下文 */
+export interface XMarkdownTagRenderContext extends XMarkdownTagAttrsContext {
+    innerHTML: string;
+    streaming: boolean;
+    typing: boolean;
+}
+/** 标签渲染器 */
+export type XMarkdownTagRenderer = (context: XMarkdownTagRenderContext) => any;
+export type XMarkdownTagRenderers = Record<string, XMarkdownTagRenderer>;
+/** 代码块渲染上下文 */
+export interface XMarkdownCodeBlockRenderContext {
+    source: string;
+    info: string;
+    language: string;
+    normalizedLanguage: string;
+    blockType: XMarkdownRenderedBlockType;
+    prefixCls: string;
+    streaming: boolean;
+    typing: boolean;
+}
+/** 代码块渲染器 */
+export type XMarkdownCodeBlockRenderer = (context: XMarkdownCodeBlockRenderContext) => any;
+export type XMarkdownCodeBlockRenderers = Record<string, XMarkdownCodeBlockRenderer>;
+/** 渲染树转换上下文 */
+export interface XMarkdownRenderTreeTransformContext {
+    source: string;
+    options: XMarkdownRenderOptions;
+}
+/** 渲染树转换器 */
+export type XMarkdownRenderTreeTransform = (nodes: XMarkdownRenderTreeNode[], context: XMarkdownRenderTreeTransformContext) => XMarkdownRenderTreeNode[] | void;
+/** Markdown 扩展插件 */
+export interface XMarkdownPlugin {
+    extendMarkdown?: (markdown: any) => void;
+    transformRenderTree?: XMarkdownRenderTreeTransform;
+}
+/** 渲染后的岛屿（用于自定义标签渲染） */
+export interface XMarkdownRenderedIsland {
+    id: string;
+    value: any;
+}
+/** 代码块类型 */
+export type XMarkdownRenderedBlockType = 'code' | 'mermaid';
+/** 渲染后的代码块信息 */
+export interface XMarkdownRenderedBlock {
+    id: string;
+    type: XMarkdownRenderedBlockType;
+    source: string;
+    language: string;
+}
+export type XMarkdownRegisterRenderedBlock = (type: XMarkdownRenderedBlockType, source: string, language: string) => string;
+/** Markdown 渲染结果 */
+export interface XMarkdownRenderResult {
+    nodes: any[];
+    blocks: Record<string, XMarkdownRenderedBlock>;
+}
+export interface XMarkdownSourceBlock {
+    key: string;
+    source: string;
+}
+export interface XMarkdownRenderedStableBlock extends XMarkdownSourceBlock {
+    nodes: any[];
+    blocks: Record<string, XMarkdownRenderedBlock>;
+}
+/** 未闭合代码块围栏信息 */
+export interface OpenFenceInfo {
+    marker: string;
+    size: number;
+    start: number;
+    language?: string;
+}
+/** 流式渲染分段结果 */
+export interface StreamingMarkdownSegments {
+    stableSource: string;
+    tailText: string;
+    openFence: OpenFenceInfo | null;
+}
+export interface XMarkdownStreamingTailCache {
+    processedLength: number;
+    completeMarkdown: string;
+    pending: string;
+    token: 'text' | 'link' | 'image' | 'html' | 'emphasis' | 'list' | 'table' | 'inline-code';
+}

package/components/xmarkdown/markdown/types.js

@@ -0,0 +1,6 @@
+/**
+ * 类型定义
+ *
+ * 集中定义 Markdown 渲染相关的所有类型。
+ */
+export {};

package/components/xmarkdown/markdown/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 工具函数
+ */
+/**
+ * 转义 HTML 特殊字符
+ */
+export declare function escapeHtml(text: string): string;

package/components/xmarkdown/markdown/utils.js

@@ -0,0 +1,9 @@
+/**
+ * 工具函数
+ */
+/**
+ * 转义 HTML 特殊字符
+ */
+export function escapeHtml(text) {
+  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}

package/components/xmarkdown/markdown.d.ts

@@ -0,0 +1 @@
+export * from './markdown/index';

package/components/xmarkdown/markdown.js

@@ -0,0 +1 @@
+export * from './markdown/index';

package/components/xmarkdown/styles.d.ts

@@ -0,0 +1,5 @@
+import '../../styles/global';
+export declare const makeStyles: {
+    (k: string): string;
+    clearCache(): {};
+};