@incremark/core 0.3.0 → 0.3.2

package/dist/{index-mZ7yCqNH.d.ts → index-CWuosVAK.d.ts}

@@ -140,6 +140,30 @@ interface ParserState {
     definitions: DefinitionMap;
     footnoteDefinitions: FootnoteDefinitionMap;
 }
+/**
+ * 数学公式配置选项
+ */
+interface MathOptions {
+    /**
+     * 启用 TeX 风格的公式分隔符 (default: `false`)
+     *
+     * 开启后同时支持：
+     * - 行内公式：\(...\)
+     * - 块级公式：\[...\]
+     *
+     * 这是 LaTeX/TeX 原生语法，MathJax 和 KaTeX 都支持。
+     * 开启此选项可以兼容从 LaTeX 文档或学术 AI 工具输出的内容。
+     *
+     * @example
+     * ```ts
+     * // 启用 TeX 风格分隔符
+     * const parser = createIncremarkParser({
+     *   math: { tex: true }
+     * })
+     * ```
+     */
+    tex?: boolean;
+}
 /**
  * 解析器配置
  */
@@ -147,11 +171,12 @@ interface ParserOptions {
     /** 启用 GFM 扩展（表格、任务列表等） */
     gfm?: boolean;
     /**
-     * 启用数学公式支持（$..$ 行内公式和 $$...$$ 块级公式）
+     * 启用数学公式支持
      * - false/undefined: 禁用（默认）
-     * - true: 启用数学公式解析
+     * - true: 启用数学公式解析（仅支持 $...$ 和 $$...$$ 语法）
+     * - MathOptions: 启用并配置额外选项（如 LaTeX 风格的 \(...\) 和 \[...\] 语法）
      */
-    math?: boolean;
+    math?: boolean | MathOptions;
     /**
      * 启用 ::: 容器语法支持（用于边界检测）
      * - false: 禁用（默认）
@@ -222,4 +247,4 @@ interface ContainerMatch {
     isEnd: boolean;
 }
 
-export type { AstNode as A, BlockStatus as B, ContainerConfig as C, DefinitionMap as D, FootnoteDefinitionMap as F, HtmlTreeExtensionOptions as H, IncrementalUpdate as I, ParsedBlock as P, ParserState as a, ParserOptions as b, BlockContext as c, ContainerMatch as d };
+export type { AstNode as A, BlockStatus as B, ContainerConfig as C, DefinitionMap as D, FootnoteDefinitionMap as F, HtmlTreeExtensionOptions as H, IncrementalUpdate as I, MathOptions as M, ParsedBlock as P, ParserState as a, ParserOptions as b, BlockContext as c, ContainerMatch as d };

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { I as IncrementalUpdate, P as ParsedBlock, D as DefinitionMap, F as FootnoteDefinitionMap, a as ParserState, B as BlockStatus } from './index-mZ7yCqNH.js';
-export { A as AstNode, b as ParserOptions } from './index-mZ7yCqNH.js';
-import { E as EngineParserOptions, I as IAstBuilder } from './types-C_EW5vfp.js';
-export { a as EngineType, b as IncremarkPlugin, M as MarkedEngineExtension, c as MicromarkEngineExtension } from './types-C_EW5vfp.js';
+import { I as IncrementalUpdate, P as ParsedBlock, D as DefinitionMap, F as FootnoteDefinitionMap, a as ParserState, B as BlockStatus } from './index-CWuosVAK.js';
+export { A as AstNode, M as MathOptions, b as ParserOptions } from './index-CWuosVAK.js';
+import { E as EngineParserOptions, I as IAstBuilder } from './types-B7GTGJc2.js';
+export { a as EngineType, b as IncremarkPlugin, M as MarkedEngineExtension, c as MicromarkEngineExtension } from './types-B7GTGJc2.js';
 import { Root, RootContent, Text } from 'mdast';
 export { Root, RootContent } from 'mdast';
-export { M as MarkedAstBuilder } from './MarkedAstBuildter-BsjxZko_.js';
+export { M as MarkedAstBuilder } from './MarkedAstBuildter-B2QhLKKy.js';
+export { collectFootnoteReferences, traverseAst } from './utils/index.js';
 import 'micromark-util-types';
 import 'mdast-util-from-markdown';
 import 'marked';
@@ -39,13 +40,12 @@ declare class IncremarkParser {
     private lineOffsets;
     private completedBlocks;
     private pendingStartLine;
-    private blockIdCounter;
     private context;
     private options;
     /** 边界检测器 */
     private readonly boundaryDetector;
     /** AST 构建器 */
-    private readonly astBuilder;
+    private astBuilder;
     /** Definition 管理器 */
     private readonly definitionManager;
     /** Footnote 管理器 */
@@ -53,7 +53,17 @@ declare class IncremarkParser {
     /** 上次 append 返回的 pending blocks，用于 getAst 复用 */
     private lastPendingBlocks;
     constructor(options?: IncremarkParserOptions);
+    /**
+     * 生成 block 的 id（直接使用 offset）
+     * @param startOffset - block 的起始偏移量
+     */
     private generateBlockId;
+    /**
+     * 生成 pending block 的稳定 id（基于 startOffset）
+     * pending blocks 在每次 append 时都会重新生成，使用 startOffset 确保 id 稳定
+     * @param startOffset - block 的起始偏移量，用作稳定的 id
+     */
+    private generatePendingBlockId;
     /**
      * 更新已完成的 blocks 中的 definitions 和 footnote definitions
      */
@@ -129,6 +139,27 @@ declare class IncremarkParser {
      * @returns 解析结果
      */
     render(content: string): IncrementalUpdate;
+    /**
+     * 更新解析器配置（动态更新，不需要重建 parser 实例）
+     *
+     * 注意：更新配置后会自动调用 reset() 重置状态
+     *
+     * @param options 部分配置选项
+     *
+     * @example
+     * ```ts
+     * // 动态启用 TeX 数学公式语法
+     * parser.updateOptions({ math: { tex: true } })
+     *
+     * // 禁用 GFM
+     * parser.updateOptions({ gfm: false })
+     *
+     * // 切换引擎
+     * import { MicromarkAstBuilder } from '@incremark/core/engines/micromark'
+     * parser.updateOptions({ astBuilder: MicromarkAstBuilder })
+     * ```
+     */
+    updateOptions(options: Partial<IncremarkParserOptions>): void;
 }
 /**
  * 创建 Incremark 解析器实例
@@ -167,13 +198,22 @@ interface SourceBlock<T = unknown> {
 }
 /**
  * 显示用的 Block（转换后）
+ *
+ * 注意：DisplayBlock 的 status 含义与 SourceBlock 不同：
+ * - SourceBlock.status: 表示**解析器**的状态（解析是否完成）
+ * - DisplayBlock.status: 表示**打字机动画**的状态（动画是否完成）
+ *
+ * 在打字机模式下：
+ * - 即使解析器已完成（SourceBlock.status = 'completed'），
+ *   如果打字机动画还在进行中，DisplayBlock.status 仍然是 'pending'
+ * - 只有打字机动画完成后，DisplayBlock.status 才变成 'completed'
  */
 interface DisplayBlock<T = unknown> extends SourceBlock<T> {
     /** 用于显示的 AST 节点（可能是截断的） */
     displayNode: RootContent;
     /** 显示进度 0-1 */
     progress: number;
-    /** 是否已完成显示 */
+    /** 是否已完成显示（打字机动画是否完成） */
     isDisplayComplete: boolean;
 }
 /**
@@ -305,7 +345,11 @@ declare class BlockTransformer<T = unknown> {
     constructor(options?: TransformerOptions);
     /**
      * 推入新的 blocks
-     * 会自动过滤已存在的 blocks
+     *
+     * 逻辑：
+     * 1. 移除不在传入列表中的旧 blocks（处理容器增量解析等场景）
+     * 2. 如果 block ID 不存在，添加到 pending
+     * 3. 如果 block ID 已存在且内容变化，更新对应位置的 block
      */
     push(blocks: SourceBlock<T>[]): void;
     /**
@@ -331,6 +375,10 @@ declare class BlockTransformer<T = unknown> {
     /**
      * 获取用于渲染的 display blocks
      * 优化：使用缓存的 displayNode，避免重复遍历已稳定的节点
+     *
+     * 注意：DisplayBlock 的 status 表示的是**打字机动画状态**，而不是解析器的状态：
+     * - 'completed': 打字机动画已完成，内容已完全显示
+     * - 'pending': 打字机动画还在进行中，内容还在逐字显示
      */
     getDisplayBlocks(): DisplayBlock<T>[];
     /**

package/dist/index.js

@@ -484,6 +484,15 @@ var BoundaryDetector = class {
       const wasInFencedCode = tempContext.inFencedCode;
       const wasInContainer = tempContext.inContainer;
       const wasContainerDepth = tempContext.containerDepth;
+      const prevLine = i > 0 ? lines[i - 1] : "";
+      const isSetextUnderline = i > 0 && isSetextHeadingUnderline(line, prevLine);
+      const hasExplicitBlockBoundary = detectFenceStart(line) || // 代码块 fence 开始
+      isHeading(line) || // 新标题开始
+      isThematicBreak(line);
+      if (!wasInFencedCode && !wasInContainer && hasExplicitBlockBoundary && !isSetextUnderline) {
+        stableLine = i - 1;
+        stableContext = { ...tempContext };
+      }
       tempContext = updateContext(line, tempContext, this.containerConfig);
       this.contextCache.set(i, { ...tempContext });
       if (wasInFencedCode && !tempContext.inFencedCode) {
@@ -547,7 +556,8 @@ var BoundaryDetector = class {
     if (isSetextHeadingUnderline(prevLine, lines[lineIndex - 2])) {
       return lineIndex - 1;
     }
-    if (lineIndex >= lines.length - 1) {
+    const isLastLine = lineIndex >= lines.length - 1;
+    if (isLastLine) {
       return -1;
     }
     for (const checker of this.checkers) {
@@ -567,6 +577,20 @@ function isDefinitionNode(node) {
 function isFootnoteDefinitionNode(node) {
   return node.type === "footnoteDefinition";
 }
+function collectFootnoteReferences(node) {
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  traverseAst(node, (n) => {
+    if (n.type === "footnoteReference" && "identifier" in n) {
+      const identifier = n.identifier;
+      if (!seen.has(identifier)) {
+        seen.add(identifier);
+        references.push(identifier);
+      }
+    }
+  });
+  return references;
+}
 function traverseAst(node, visitor) {
   const stopEarly = visitor(node);
   if (stopEarly === true) {
@@ -1351,24 +1375,48 @@ function createOptimisticReferenceExtension() {
 }
 
 // src/extensions/marked-extensions/mathExtension.ts
-function createBlockMathExtension() {
+function resolveOptions(options) {
+  return {
+    tex: options?.tex ?? false
+  };
+}
+function createBlockMathExtension(options) {
+  const resolved = resolveOptions(options);
   return {
     name: "blockMath",
     level: "block",
     start(src) {
-      const match = src.match(/^ {0,3}\$\$/m);
-      return match?.index;
+      const dollarMatch = src.match(/^ {0,3}\$\$/m);
+      let bracketMatch = null;
+      if (resolved.tex) {
+        bracketMatch = src.match(/^ {0,3}\\\[/m);
+      }
+      if (dollarMatch && bracketMatch) {
+        return Math.min(dollarMatch.index, bracketMatch.index);
+      }
+      return dollarMatch?.index ?? bracketMatch?.index;
     },
     tokenizer(src) {
-      const rule = /^ {0,3}\$\$([\s\S]*?)\$\$ *(?:\n+|$)/;
-      const match = rule.exec(src);
-      if (match) {
+      const dollarRule = /^ {0,3}\$\$([\s\S]*?)\$\$ *(?:\n+|$)/;
+      const dollarMatch = dollarRule.exec(src);
+      if (dollarMatch) {
         return {
           type: "blockMath",
-          raw: match[0],
-          text: match[1].trim()
+          raw: dollarMatch[0],
+          text: dollarMatch[1].trim()
         };
       }
+      if (resolved.tex) {
+        const bracketRule = /^ {0,3}\\\[([\s\S]*?)\\\] *(?:\n+|$)/;
+        const bracketMatch = bracketRule.exec(src);
+        if (bracketMatch) {
+          return {
+            type: "blockMath",
+            raw: bracketMatch[0],
+            text: bracketMatch[1].trim()
+          };
+        }
+      }
       return void 0;
     },
     renderer() {
@@ -1376,26 +1424,46 @@ function createBlockMathExtension() {
     }
   };
 }
-function createInlineMathExtension() {
+function createInlineMathExtension(options) {
+  const resolved = resolveOptions(options);
   return {
     name: "inlineMath",
     level: "inline",
     start(src) {
-      const index = src.indexOf("$");
-      if (index === -1) return void 0;
-      if (src[index + 1] === "$") return void 0;
-      return index;
+      const dollarIndex = src.indexOf("$");
+      const validDollarIndex = dollarIndex !== -1 && src[dollarIndex + 1] !== "$" ? dollarIndex : -1;
+      let parenIndex = -1;
+      if (resolved.tex) {
+        parenIndex = src.indexOf("\\(");
+      }
+      if (validDollarIndex !== -1 && parenIndex !== -1) {
+        return Math.min(validDollarIndex, parenIndex);
+      }
+      if (validDollarIndex !== -1) return validDollarIndex;
+      if (parenIndex !== -1) return parenIndex;
+      return void 0;
     },
     tokenizer(src) {
-      const rule = /^\$(?!\$)((?:\\.|[^\\\n$])+?)\$(?!\d)/;
-      const match = rule.exec(src);
-      if (match) {
+      const dollarRule = /^\$(?!\$)((?:\\.|[^\\\n$])+?)\$(?!\d)/;
+      const dollarMatch = dollarRule.exec(src);
+      if (dollarMatch) {
         return {
           type: "inlineMath",
-          raw: match[0],
-          text: match[1].trim()
+          raw: dollarMatch[0],
+          text: dollarMatch[1].trim()
         };
       }
+      if (resolved.tex) {
+        const parenRule = /^\\\(([\s\S]*?)\\\)/;
+        const parenMatch = parenRule.exec(src);
+        if (parenMatch) {
+          return {
+            type: "inlineMath",
+            raw: parenMatch[0],
+            text: parenMatch[1].trim()
+          };
+        }
+      }
       return void 0;
     },
     renderer() {
@@ -2053,8 +2121,9 @@ var MarkedAstBuilder = class {
     const inlineExts = [optimisticRefExt.tokenizer, ...userInlineExts];
     const inlineStartExts = [optimisticRefExt.start, ...userInlineStartExts];
     if (this.options.math) {
-      const blockMathExt = createBlockMathExtension();
-      const inlineMathExt = createInlineMathExtension();
+      const mathOptions = typeof this.options.math === "object" ? this.options.math : {};
+      const blockMathExt = createBlockMathExtension(mathOptions);
+      const inlineMathExt = createInlineMathExtension(mathOptions);
       blockExts.unshift(blockMathExt.tokenizer);
       blockStartExts.unshift(blockMathExt.start);
       inlineExts.unshift(inlineMathExt.tokenizer);
@@ -2270,7 +2339,7 @@ var MarkedAstBuilder = class {
       const absoluteStart = startOffset + relativeStart;
       const absoluteEnd = startOffset + relativeEnd;
       blocks.push({
-        id: generateBlockId(),
+        id: generateBlockId(absoluteStart),
         status,
         node,
         startOffset: absoluteStart,
@@ -2280,6 +2349,28 @@ var MarkedAstBuilder = class {
     }
     return blocks;
   }
+  /**
+   * 更新配置选项
+   * @param options 部分配置选项
+   */
+  updateOptions(options) {
+    Object.assign(this.options, options);
+    if ("containers" in options) {
+      this.containerConfig = typeof options.containers === "object" ? options.containers : options.containers === true ? {} : void 0;
+    }
+    if ("htmlTree" in options) {
+      this.htmlTreeOptions = typeof options.htmlTree === "object" ? options.htmlTree : options.htmlTree === true ? {} : void 0;
+    }
+    if (options.plugins || options.markedExtensions) {
+      this.userExtensions.length = 0;
+      if (options.plugins) {
+        this.userExtensions.push(...extractMarkedExtensions(options.plugins));
+      }
+      if (options.markedExtensions) {
+        this.userExtensions.push(...options.markedExtensions);
+      }
+    }
+  }
 };
 
 // src/parser/IncremarkParser.ts
@@ -2289,7 +2380,6 @@ var IncremarkParser = class {
   lineOffsets = [0];
   completedBlocks = [];
   pendingStartLine = 0;
-  blockIdCounter = 0;
   context;
   options;
   /** 边界检测器 */
@@ -2314,8 +2404,20 @@ var IncremarkParser = class {
     this.definitionManager = new DefinitionManager();
     this.footnoteManager = new FootnoteManager();
   }
-  generateBlockId() {
-    return `block-${++this.blockIdCounter}`;
+  /**
+   * 生成 block 的 id（直接使用 offset）
+   * @param startOffset - block 的起始偏移量
+   */
+  generateBlockId(startOffset) {
+    return String(startOffset);
+  }
+  /**
+   * 生成 pending block 的稳定 id（基于 startOffset）
+   * pending blocks 在每次 append 时都会重新生成，使用 startOffset 确保 id 稳定
+   * @param startOffset - block 的起始偏移量，用作稳定的 id
+   */
+  generatePendingBlockId(startOffset) {
+    return String(startOffset);
   }
   /**
    * 更新已完成的 blocks 中的 definitions 和 footnote definitions
@@ -2387,9 +2489,28 @@ var IncremarkParser = class {
       const stableText = this.lines.slice(this.pendingStartLine, stableBoundary + 1).join("\n");
       const stableOffset = this.getLineOffset(this.pendingStartLine);
       const ast = this.astBuilder.parse(stableText);
-      const newBlocks = this.astBuilder.nodesToBlocks(ast.children, stableOffset, stableText, "completed", () => this.generateBlockId());
+      const newBlocks = this.astBuilder.nodesToBlocks(ast.children, stableOffset, stableText, "completed", (offset) => this.generateBlockId(offset));
+      const blocksToRemove = [];
+      for (const newBlock of newBlocks) {
+        for (const existingBlock of this.completedBlocks) {
+          const isOverlapping = newBlock.startOffset >= existingBlock.startOffset && newBlock.startOffset < existingBlock.endOffset;
+          const isOverlappingReverse = existingBlock.startOffset >= newBlock.startOffset && existingBlock.startOffset < newBlock.endOffset;
+          if (isOverlapping || isOverlappingReverse) {
+            if (newBlock.id !== existingBlock.id) {
+              blocksToRemove.push(existingBlock);
+            }
+          }
+        }
+      }
+      if (blocksToRemove.length > 0) {
+        const idsToRemove = new Set(blocksToRemove.map((b) => b.id));
+        this.completedBlocks = this.completedBlocks.filter((b) => !idsToRemove.has(b.id));
+      }
       this.completedBlocks.push(...newBlocks);
       update.completed = newBlocks;
+      if (blocksToRemove.length > 0) {
+        update.updated = blocksToRemove;
+      }
       this.updateDefinitionsFromCompletedBlocks(newBlocks);
       this.footnoteManager.collectReferencesFromCompletedBlocks(newBlocks);
       this.boundaryDetector.clearContextCache(this.pendingStartLine);
@@ -2401,7 +2522,13 @@ var IncremarkParser = class {
       if (pendingText.trim()) {
         const pendingOffset = this.getLineOffset(this.pendingStartLine);
         const ast = this.astBuilder.parse(pendingText);
-        update.pending = this.astBuilder.nodesToBlocks(ast.children, pendingOffset, pendingText, "pending", () => this.generateBlockId());
+        update.pending = this.astBuilder.nodesToBlocks(
+          ast.children,
+          pendingOffset,
+          pendingText,
+          "pending",
+          (offset) => this.generatePendingBlockId(offset)
+        );
       }
     }
     this.lastPendingBlocks = update.pending;
@@ -2461,7 +2588,7 @@ var IncremarkParser = class {
           remainingOffset,
           remainingText,
           "completed",
-          () => this.generateBlockId()
+          (offset) => this.generateBlockId(offset)
         );
         this.completedBlocks.push(...finalBlocks);
         update.completed = finalBlocks;
@@ -2552,7 +2679,6 @@ var IncremarkParser = class {
     this.lineOffsets = [0];
     this.completedBlocks = [];
     this.pendingStartLine = 0;
-    this.blockIdCounter = 0;
     this.context = createInitialContext();
     this.lastPendingBlocks = [];
     this.definitionManager.clear();
@@ -2569,6 +2695,40 @@ var IncremarkParser = class {
     this.append(content);
     return this.finalize();
   }
+  /**
+   * 更新解析器配置（动态更新，不需要重建 parser 实例）
+   *
+   * 注意：更新配置后会自动调用 reset() 重置状态
+   *
+   * @param options 部分配置选项
+   *
+   * @example
+   * ```ts
+   * // 动态启用 TeX 数学公式语法
+   * parser.updateOptions({ math: { tex: true } })
+   *
+   * // 禁用 GFM
+   * parser.updateOptions({ gfm: false })
+   *
+   * // 切换引擎
+   * import { MicromarkAstBuilder } from '@incremark/core/engines/micromark'
+   * parser.updateOptions({ astBuilder: MicromarkAstBuilder })
+   * ```
+   */
+  updateOptions(options) {
+    this.reset();
+    Object.assign(this.options, options);
+    if (options.astBuilder) {
+      const BuilderClass = options.astBuilder;
+      if (!(this.astBuilder instanceof BuilderClass)) {
+        this.astBuilder = new BuilderClass(this.options);
+      } else {
+        this.astBuilder.updateOptions(options);
+      }
+    } else {
+      this.astBuilder.updateOptions(options);
+    }
+  }
 };
 function createIncremarkParser(options) {
   return new IncremarkParser(options);
@@ -2784,21 +2944,77 @@ var BlockTransformer = class {
   }
   /**
    * 推入新的 blocks
-   * 会自动过滤已存在的 blocks
+   *
+   * 逻辑：
+   * 1. 移除不在传入列表中的旧 blocks（处理容器增量解析等场景）
+   * 2. 如果 block ID 不存在，添加到 pending
+   * 3. 如果 block ID 已存在且内容变化，更新对应位置的 block
    */
   push(blocks) {
+    const inputIds = new Set(blocks.map((b) => b.id));
     const existingIds = this.getAllBlockIds();
+    let hasRemovals = false;
+    const completedBefore = this.state.completedBlocks.length;
+    this.state.completedBlocks = this.state.completedBlocks.filter((b) => inputIds.has(b.id));
+    if (this.state.completedBlocks.length < completedBefore) {
+      hasRemovals = true;
+    }
+    if (this.state.currentBlock && !inputIds.has(this.state.currentBlock.id)) {
+      this.state.currentBlock = null;
+      this.state.currentProgress = 0;
+      this.chunks = [];
+      this.clearCache();
+      hasRemovals = true;
+    }
+    const pendingBefore = this.state.pendingBlocks.length;
+    this.state.pendingBlocks = this.state.pendingBlocks.filter((b) => inputIds.has(b.id));
+    if (this.state.pendingBlocks.length < pendingBefore) {
+      hasRemovals = true;
+    }
+    if (hasRemovals && !this.state.currentBlock && this.state.pendingBlocks.length > 0) {
+      this.startIfNeeded();
+    }
     const newBlocks = blocks.filter((b) => !existingIds.has(b.id));
     if (newBlocks.length > 0) {
       this.state.pendingBlocks.push(...newBlocks);
       this.startIfNeeded();
     }
-    if (this.state.currentBlock) {
-      const updated = blocks.find((b) => b.id === this.state.currentBlock.id);
-      if (updated && updated.node !== this.state.currentBlock.node) {
-        this.handleContentChange(this.state.currentBlock.node, updated.node, true);
-        this.state.currentBlock = updated;
+    for (const block of blocks) {
+      if (!existingIds.has(block.id)) continue;
+      if (this.state.currentBlock?.id === block.id) {
+        const total = this.getTotalChars();
+        const isComplete = this.state.currentProgress >= total;
+        if (isComplete) {
+          this.state.completedBlocks.push(block);
+          this.state.currentBlock = null;
+          this.state.currentProgress = 0;
+          this.chunks = [];
+          this.clearCache();
+          this.processNext();
+        } else if (this.state.currentBlock.node !== block.node) {
+          this.handleContentChange(this.state.currentBlock.node, block.node, true);
+          this.state.currentBlock = block;
+        }
+        continue;
+      }
+      const completedIndex = this.state.completedBlocks.findIndex((b) => b.id === block.id);
+      if (completedIndex !== -1) {
+        if (this.state.completedBlocks[completedIndex].node !== block.node) {
+          this.state.completedBlocks[completedIndex] = block;
+          this.emit();
+        }
+        continue;
       }
+      const pendingIndex = this.state.pendingBlocks.findIndex((b) => b.id === block.id);
+      if (pendingIndex !== -1) {
+        if (this.state.pendingBlocks[pendingIndex].node !== block.node) {
+          this.state.pendingBlocks[pendingIndex] = block;
+        }
+        continue;
+      }
+    }
+    if (hasRemovals) {
+      this.emit();
     }
   }
   /**
@@ -2808,6 +3024,18 @@ var BlockTransformer = class {
     if (this.state.currentBlock?.id === block.id) {
       this.handleContentChange(this.state.currentBlock.node, block.node, false);
       this.state.currentBlock = block;
+      return;
+    }
+    const completedIndex = this.state.completedBlocks.findIndex((b) => b.id === block.id);
+    if (completedIndex !== -1) {
+      this.state.completedBlocks[completedIndex] = block;
+      this.emit();
+      return;
+    }
+    const pendingIndex = this.state.pendingBlocks.findIndex((b) => b.id === block.id);
+    if (pendingIndex !== -1) {
+      this.state.pendingBlocks[pendingIndex] = block;
+      return;
     }
   }
   /**
@@ -2865,12 +3093,18 @@ var BlockTransformer = class {
   /**
    * 获取用于渲染的 display blocks
    * 优化：使用缓存的 displayNode，避免重复遍历已稳定的节点
+   *
+   * 注意：DisplayBlock 的 status 表示的是**打字机动画状态**，而不是解析器的状态：
+   * - 'completed': 打字机动画已完成，内容已完全显示
+   * - 'pending': 打字机动画还在进行中，内容还在逐字显示
    */
   getDisplayBlocks() {
     const result = [];
     for (const block of this.state.completedBlocks) {
       result.push({
         ...block,
+        // 打字机动画已完成，状态为 completed
+        status: "completed",
         displayNode: block.node,
         progress: 1,
         isDisplayComplete: true
@@ -2883,6 +3117,8 @@ var BlockTransformer = class {
       }
       result.push({
         ...this.state.currentBlock,
+        // 打字机动画进行中，状态为 pending
+        status: "pending",
         displayNode: this.cachedDisplayNode || { type: "paragraph", children: [] },
         progress: total > 0 ? this.state.currentProgress / total : 1,
         isDisplayComplete: false
@@ -3309,6 +3545,6 @@ function createPlugin(name, matcher, options = {}) {
   };
 }
 
-export { BlockTransformer, IncremarkParser, MarkedAstBuilder, allPlugins, cloneNode, codeBlockPlugin, countChars, createBlockTransformer, createIncremarkParser, createPlugin, defaultPlugins, imagePlugin, mathPlugin, mermaidPlugin, sliceAst, thematicBreakPlugin };
+export { BlockTransformer, IncremarkParser, MarkedAstBuilder, allPlugins, cloneNode, codeBlockPlugin, collectFootnoteReferences, countChars, createBlockTransformer, createIncremarkParser, createPlugin, defaultPlugins, imagePlugin, mathPlugin, mermaidPlugin, sliceAst, thematicBreakPlugin, traverseAst };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map