@incremark/core 0.2.6 → 0.3.0

package/dist/index.js

@@ -1,21 +1,758 @@
-import { fromMarkdown } from 'mdast-util-from-markdown';
-import { gfmFromMarkdown } from 'mdast-util-gfm';
-import { gfm } from 'micromark-extension-gfm';
-import { gfmFootnoteFromMarkdown } from 'mdast-util-gfm-footnote';
-import { math } from 'micromark-extension-math';
-import { mathFromMarkdown } from 'mdast-util-math';
-import { codes, constants, types } from 'micromark-util-symbol';
-import { markdownLineEndingOrSpace } from 'micromark-util-character';
-import { factoryDestination } from 'micromark-factory-destination';
-import { factoryTitle } from 'micromark-factory-title';
-import { factoryLabel } from 'micromark-factory-label';
-import { factoryWhitespace } from 'micromark-factory-whitespace';
-import { gfmFootnote } from 'micromark-extension-gfm-footnote';
-import { normalizeIdentifier } from 'micromark-util-normalize-identifier';
-import { directive } from 'micromark-extension-directive';
-import { directiveFromMarkdown } from 'mdast-util-directive';
+import { Lexer, lexer } from 'marked';
 
-// src/parser/IncremarkParser.ts
+// src/detector/index.ts
+var RE_FENCE_START = /^(\s*)((`{3,})|(~{3,}))/;
+var RE_EMPTY_LINE = /^\s*$/;
+var RE_HEADING = /^#{1,6}\s/;
+var RE_THEMATIC_BREAK = /^(\*{3,}|-{3,}|_{3,})\s*$/;
+var RE_BLOCKQUOTE = /^\s{0,3}>/;
+var RE_ESCAPE_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+var RE_FOOTNOTE_DEFINITION = /^\[\^([^\]]+)\]:\s/;
+var RE_FOOTNOTE_CONTINUATION = /^(?:    |\t)/;
+var fenceEndPatternCache = /* @__PURE__ */ new Map();
+var containerPatternCache = /* @__PURE__ */ new Map();
+function detectFenceStart(line) {
+  const match = line.match(RE_FENCE_START);
+  if (match) {
+    const fence = match[2];
+    const char = fence[0];
+    return { char, length: fence.length };
+  }
+  return null;
+}
+function detectFenceEnd(line, context) {
+  if (!context.inFencedCode || !context.fenceChar || !context.fenceLength) {
+    return false;
+  }
+  const cacheKey = `${context.fenceChar}-${context.fenceLength}`;
+  let pattern = fenceEndPatternCache.get(cacheKey);
+  if (!pattern) {
+    pattern = new RegExp(`^\\s{0,3}${context.fenceChar}{${context.fenceLength},}\\s*$`);
+    fenceEndPatternCache.set(cacheKey, pattern);
+  }
+  return pattern.test(line);
+}
+function isEmptyLine(line) {
+  return RE_EMPTY_LINE.test(line);
+}
+function isSetextHeadingUnderline(line, prevLine) {
+  const trimmed = line.trim();
+  if (!/^={3,}$|^-{3,}$/.test(trimmed)) {
+    return false;
+  }
+  if (!prevLine) {
+    return false;
+  }
+  const trimmedPrev = prevLine.trim();
+  if (trimmedPrev === "") {
+    return false;
+  }
+  if (/^#{1,6}\s/.test(trimmedPrev) || /^(\*{3,}|-{3,}|_{3,})\s*$/.test(trimmedPrev)) {
+    return false;
+  }
+  if (/^(\s*)([-*+])\s/.test(trimmedPrev) || /^(\s*)(\d{1,9})[.)]\s/.test(trimmedPrev)) {
+    return false;
+  }
+  if (/^\s{0,3}>/.test(trimmedPrev)) {
+    return false;
+  }
+  if (/^(\s*)(`{3,}|~{3,})/.test(trimmedPrev)) {
+    return false;
+  }
+  const underlineIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
+  if (underlineIndent > 3) {
+    return false;
+  }
+  const contentIndent = prevLine.match(/^(\s*)/)?.[1].length ?? 0;
+  if (contentIndent > 3) {
+    return false;
+  }
+  return true;
+}
+function isHeading(line) {
+  return RE_HEADING.test(line);
+}
+function isThematicBreak(line) {
+  return RE_THEMATIC_BREAK.test(line.trim());
+}
+function isListItemStart(line) {
+  const hasListMarker = /^(\s*)([-*+]|\d{1,9}[.)])/.test(line);
+  if (!hasListMarker) {
+    return null;
+  }
+  const match = line.match(/^(\s*)([-*+]|\d{1,9}[.)])(.*)/);
+  if (match) {
+    const indent = match[1].length;
+    const marker = match[2];
+    const rest = match[3];
+    if (rest.trim()) {
+      const isOrdered = /^\d{1,9}[.)]/.test(marker);
+      return { ordered: isOrdered, indent };
+    }
+    if (/^\s+$/.test(rest)) {
+      const isOrdered = /^\d{1,9}[.)]/.test(marker);
+      return { ordered: isOrdered, indent };
+    }
+  }
+  return null;
+}
+function isBlockquoteStart(line) {
+  return RE_BLOCKQUOTE.test(line);
+}
+function isFootnoteDefinitionStart(line) {
+  return RE_FOOTNOTE_DEFINITION.test(line);
+}
+function isFootnoteContinuation(line) {
+  return RE_FOOTNOTE_CONTINUATION.test(line);
+}
+function detectContainer(line, config) {
+  const marker = config?.marker || ":";
+  const minLength = config?.minMarkerLength || 3;
+  const cacheKey = `${marker}-${minLength}`;
+  let pattern = containerPatternCache.get(cacheKey);
+  if (!pattern) {
+    const escapedMarker = marker.replace(RE_ESCAPE_SPECIAL, "\\$&");
+    pattern = new RegExp(
+      `^(\\s*)(${escapedMarker}{${minLength},})(?:\\s*(\\w[\\w-]*))?(?:\\{[^}]*\\})?(?:\\s+(.*))?\\s*$`
+    );
+    containerPatternCache.set(cacheKey, pattern);
+  }
+  const match = line.match(pattern);
+  if (!match) {
+    return null;
+  }
+  const markerLength = match[2].length;
+  const name = match[3] || "";
+  const isEnd = !name && !match[4];
+  if (!isEnd && config?.allowedNames && config.allowedNames.length > 0) {
+    if (!config.allowedNames.includes(name)) {
+      return null;
+    }
+  }
+  return { name, markerLength, isEnd };
+}
+function detectContainerEnd(line, context, config) {
+  if (!context.inContainer || !context.containerMarkerLength) {
+    return false;
+  }
+  const result = detectContainer(line, config);
+  if (!result) {
+    return false;
+  }
+  return result.isEnd && result.markerLength >= context.containerMarkerLength;
+}
+var CodeContextUpdater = class {
+  update(line, context) {
+    const newContext = { ...context };
+    if (context.inFencedCode) {
+      if (detectFenceEnd(line, context)) {
+        newContext.inFencedCode = false;
+        newContext.fenceChar = void 0;
+        newContext.fenceLength = void 0;
+        return newContext;
+      }
+      return null;
+    }
+    const fence = detectFenceStart(line);
+    if (fence) {
+      newContext.inFencedCode = true;
+      newContext.fenceChar = fence.char;
+      newContext.fenceLength = fence.length;
+      return newContext;
+    }
+    return null;
+  }
+};
+var ContainerContextUpdater = class {
+  update(line, context, config) {
+    if (config === void 0) {
+      return null;
+    }
+    const newContext = { ...context };
+    if (context.inContainer) {
+      if (detectContainerEnd(line, context, config)) {
+        newContext.containerDepth = context.containerDepth - 1;
+        if (newContext.containerDepth === 0) {
+          newContext.inContainer = false;
+          newContext.containerMarkerLength = void 0;
+          newContext.containerName = void 0;
+        }
+        return newContext;
+      }
+      const nested = detectContainer(line, config);
+      if (nested && !nested.isEnd) {
+        newContext.containerDepth = context.containerDepth + 1;
+        return newContext;
+      }
+      return newContext;
+    } else {
+      const container = detectContainer(line, config);
+      if (container && !container.isEnd) {
+        newContext.inContainer = true;
+        newContext.containerMarkerLength = container.markerLength;
+        newContext.containerName = container.name;
+        newContext.containerDepth = 1;
+        return newContext;
+      }
+    }
+    return null;
+  }
+};
+var FootnoteContextUpdater = class {
+  update(line, context) {
+    const newContext = { ...context };
+    if (!context.inFootnote && isFootnoteDefinitionStart(line)) {
+      const identifier = line.match(RE_FOOTNOTE_DEFINITION)?.[1];
+      newContext.inFootnote = true;
+      newContext.footnoteIdentifier = identifier;
+      return newContext;
+    }
+    if (context.inFootnote) {
+      if (isFootnoteDefinitionStart(line)) {
+        const identifier = line.match(RE_FOOTNOTE_DEFINITION)?.[1];
+        newContext.footnoteIdentifier = identifier;
+        return newContext;
+      }
+      if (isEmptyLine(line)) {
+        return { ...context };
+      }
+      const listItem = isListItemStart(line);
+      if (listItem) {
+        if (listItem.indent === 0) {
+          newContext.inFootnote = false;
+          newContext.footnoteIdentifier = void 0;
+        } else {
+          return { ...context };
+        }
+        return null;
+      }
+      if (isHeading(line) || detectFenceStart(line) || isBlockquoteStart(line)) {
+        newContext.inFootnote = false;
+        newContext.footnoteIdentifier = void 0;
+        return newContext;
+      }
+      if (isFootnoteContinuation(line)) {
+        return { ...context };
+      }
+      newContext.inFootnote = false;
+      newContext.footnoteIdentifier = void 0;
+      return newContext;
+    }
+    return null;
+  }
+};
+var ListContextUpdater = class {
+  /**
+   * 检测是否是列表项的延续内容（缩进内容或空行）
+   */
+  isListContinuation(line, listIndent) {
+    if (isEmptyLine(line)) {
+      return true;
+    }
+    const contentIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
+    return contentIndent > listIndent;
+  }
+  update(line, context) {
+    const newContext = { ...context };
+    const listItem = isListItemStart(line);
+    if (context.inList) {
+      if (context.listMayEnd) {
+        if (listItem) {
+          if (listItem.ordered === context.listOrdered && listItem.indent === context.listIndent) {
+            newContext.listMayEnd = false;
+            return newContext;
+          }
+          newContext.listOrdered = listItem.ordered;
+          newContext.listIndent = listItem.indent;
+          newContext.listMayEnd = false;
+          return newContext;
+        } else if (this.isListContinuation(line, context.listIndent ?? 0)) {
+          newContext.listMayEnd = isEmptyLine(line);
+          return newContext;
+        } else {
+          newContext.inList = false;
+          newContext.listOrdered = void 0;
+          newContext.listIndent = void 0;
+          newContext.listMayEnd = false;
+          return newContext;
+        }
+      } else {
+        if (listItem) {
+          return null;
+        } else if (isEmptyLine(line)) {
+          newContext.listMayEnd = true;
+          return newContext;
+        } else if (this.isListContinuation(line, context.listIndent ?? 0)) {
+          return null;
+        } else {
+          newContext.inList = false;
+          newContext.listOrdered = void 0;
+          newContext.listIndent = void 0;
+          newContext.listMayEnd = false;
+          return newContext;
+        }
+      }
+    } else {
+      if (listItem) {
+        newContext.inList = true;
+        newContext.listOrdered = listItem.ordered;
+        newContext.listIndent = listItem.indent;
+        newContext.listMayEnd = false;
+        return newContext;
+      }
+    }
+    return null;
+  }
+};
+function createInitialContext() {
+  return {
+    inFencedCode: false,
+    listDepth: 0,
+    blockquoteDepth: 0,
+    inContainer: false,
+    containerDepth: 0,
+    inList: false,
+    inFootnote: false,
+    footnoteIdentifier: void 0
+  };
+}
+var ContextManager = class {
+  updaters = [
+    new CodeContextUpdater(),
+    new ContainerContextUpdater(),
+    new FootnoteContextUpdater(),
+    new ListContextUpdater()
+  ];
+  /**
+   * 更新上下文（处理一行后）
+   *
+   * @param line 当前行
+   * @param context 当前上下文
+   * @param containerConfig 容器配置
+   * @returns 更新后的上下文
+   */
+  update(line, context, containerConfig) {
+    const config = containerConfig === true ? {} : containerConfig === false ? void 0 : containerConfig;
+    for (const updater of this.updaters) {
+      const result = updater.update(line, context, config);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return { ...context };
+  }
+};
+var contextManager = new ContextManager();
+function updateContext(line, context, containerConfig) {
+  return contextManager.update(line, context, containerConfig);
+}
+
+// src/parser/boundary/BoundaryDetector.ts
+var ContainerBoundaryChecker = class {
+  constructor(containerConfig) {
+    this.containerConfig = containerConfig;
+  }
+  check(lineIndex, context, lines) {
+    const line = lines[lineIndex];
+    if (!context.inContainer) {
+      return -1;
+    }
+    if (this.containerConfig !== void 0) {
+      const containerEnd = detectContainerEnd(line, context, this.containerConfig);
+      if (containerEnd) {
+        return lineIndex - 1;
+      }
+    }
+    return -1;
+  }
+};
+var ListBoundaryChecker = class {
+  check(lineIndex, context, lines) {
+    if (!context.inList) {
+      return -1;
+    }
+    if (!context.listMayEnd) {
+      return -1;
+    }
+    const line = lines[lineIndex];
+    const listItem = isListItemStart(line);
+    const contentIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
+    const isListContent = contentIndent > (context.listIndent ?? 0);
+    if (!listItem && !isListContent && !isEmptyLine(line)) {
+      return lineIndex - 1;
+    }
+    return -1;
+  }
+};
+var FootnoteBoundaryChecker = class {
+  check(lineIndex, context, lines) {
+    const line = lines[lineIndex];
+    const prevLine = lines[lineIndex - 1];
+    if (isFootnoteDefinitionStart(prevLine)) {
+      if (isEmptyLine(line) || isFootnoteContinuation(line)) {
+        return -1;
+      }
+      if (isFootnoteDefinitionStart(line)) {
+        return lineIndex - 1;
+      }
+    }
+    if (!isEmptyLine(prevLine) && isFootnoteContinuation(prevLine)) {
+      return -1;
+    }
+    if (!isEmptyLine(prevLine) && isFootnoteDefinitionStart(line) && !isFootnoteDefinitionStart(prevLine)) {
+      return lineIndex - 1;
+    }
+    return -1;
+  }
+};
+var NewBlockBoundaryChecker = class {
+  check(lineIndex, context, lines) {
+    const line = lines[lineIndex];
+    const prevLine = lines[lineIndex - 1];
+    if (isEmptyLine(prevLine)) {
+      return -1;
+    }
+    if (isSetextHeadingUnderline(line, prevLine)) {
+      return lineIndex - 1;
+    }
+    if (isHeading(line)) {
+      return lineIndex - 1;
+    }
+    if (detectFenceStart(line)) {
+      return lineIndex - 1;
+    }
+    if (isBlockquoteStart(line) && !isBlockquoteStart(prevLine)) {
+      return lineIndex - 1;
+    }
+    if (!context.inList && isListItemStart(line) && !isListItemStart(prevLine)) {
+      return lineIndex - 1;
+    }
+    return -1;
+  }
+};
+var EmptyLineBoundaryChecker = class {
+  check(lineIndex, context, lines) {
+    const line = lines[lineIndex];
+    const prevLine = lines[lineIndex - 1];
+    if (isEmptyLine(line) && !isEmptyLine(prevLine) && !context.inList) {
+      return lineIndex;
+    }
+    return -1;
+  }
+};
+var BoundaryDetector = class {
+  containerConfig;
+  checkers;
+  /** 缓存每一行结束时对应的 Context，避免重复计算 */
+  contextCache = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.containerConfig = config.containers;
+    this.checkers = [
+      new ContainerBoundaryChecker(this.containerConfig),
+      new ListBoundaryChecker(),
+      new FootnoteBoundaryChecker(),
+      new NewBlockBoundaryChecker(),
+      new EmptyLineBoundaryChecker()
+    ];
+  }
+  /**
+   * 清空上下文缓存
+   * 当 pendingStartLine 推进后调用，释放不再需要的缓存
+   */
+  clearContextCache(beforeLine) {
+    for (const key of this.contextCache.keys()) {
+      if (key < beforeLine) {
+        this.contextCache.delete(key);
+      }
+    }
+  }
+  /**
+   * 查找稳定边界
+   * 返回稳定边界行号和该行对应的上下文（用于后续更新，避免重复计算）
+   *
+   * @param lines 所有行
+   * @param startLine 起始行
+   * @param context 当前上下文
+   * @returns 稳定边界结果
+   */
+  findStableBoundary(lines, startLine, context) {
+    let stableLine = -1;
+    let stableContext = context;
+    let tempContext = startLine > 0 && this.contextCache.has(startLine - 1) ? { ...this.contextCache.get(startLine - 1) } : { ...context };
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      const wasInFencedCode = tempContext.inFencedCode;
+      const wasInContainer = tempContext.inContainer;
+      const wasContainerDepth = tempContext.containerDepth;
+      tempContext = updateContext(line, tempContext, this.containerConfig);
+      this.contextCache.set(i, { ...tempContext });
+      if (wasInFencedCode && !tempContext.inFencedCode) {
+        if (i < lines.length - 1) {
+          stableLine = i;
+          stableContext = { ...tempContext };
+        }
+        continue;
+      }
+      if (tempContext.inFencedCode) {
+        continue;
+      }
+      if (wasInContainer && wasContainerDepth === 1 && !tempContext.inContainer) {
+        if (i < lines.length - 1) {
+          stableLine = i;
+          stableContext = { ...tempContext };
+        }
+        continue;
+      }
+      if (tempContext.inContainer) {
+        continue;
+      }
+      const stablePoint = this.checkStability(i, tempContext, lines);
+      if (stablePoint >= 0) {
+        stableLine = stablePoint;
+        stableContext = { ...tempContext };
+      }
+    }
+    return { line: stableLine, context: stableContext };
+  }
+  /**
+   * 检查指定行是否是稳定边界
+   * 使用责任链模式，依次调用各个检查器
+   *
+   * @param lineIndex 行索引
+   * @param context 当前上下文
+   * @param lines 所有行
+   * @returns 稳定边界行号，如果不是稳定边界返回 -1
+   */
+  checkStability(lineIndex, context, lines) {
+    if (lineIndex === 0) {
+      return -1;
+    }
+    const line = lines[lineIndex];
+    const prevLine = lines[lineIndex - 1];
+    if (context.inFootnote) {
+      if (isFootnoteDefinitionStart(prevLine) && !isEmptyLine(line)) {
+        if (isFootnoteContinuation(line)) {
+          return -1;
+        }
+        return lineIndex - 1;
+      }
+      if (isEmptyLine(prevLine) && (isEmptyLine(line) || isFootnoteContinuation(line))) {
+        return -1;
+      }
+      return -1;
+    }
+    if (isHeading(prevLine) || isThematicBreak(prevLine)) {
+      return lineIndex - 1;
+    }
+    if (isSetextHeadingUnderline(prevLine, lines[lineIndex - 2])) {
+      return lineIndex - 1;
+    }
+    if (lineIndex >= lines.length - 1) {
+      return -1;
+    }
+    for (const checker of this.checkers) {
+      const stablePoint = checker.check(lineIndex, context, lines);
+      if (stablePoint >= 0) {
+        return stablePoint;
+      }
+    }
+    return -1;
+  }
+};
+
+// src/utils/index.ts
+function isDefinitionNode(node) {
+  return node.type === "definition";
+}
+function isFootnoteDefinitionNode(node) {
+  return node.type === "footnoteDefinition";
+}
+function traverseAst(node, visitor) {
+  const stopEarly = visitor(node);
+  if (stopEarly === true) {
+    return;
+  }
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      traverseAst(child, visitor);
+    }
+  }
+}
+function collectAstNodes(node, predicate) {
+  const results = [];
+  traverseAst(node, (node2) => {
+    if (predicate(node2)) {
+      results.push(node2);
+    }
+  });
+  return results;
+}
+
+// src/parser/manager/DefinitionManager.ts
+var DefinitionManager = class {
+  definitions = {};
+  /**
+   * 从已完成的 blocks 中提取 definitions
+   *
+   * @param blocks 已完成的块
+   */
+  extractFromBlocks(blocks) {
+    for (const block of blocks) {
+      const newDefinitions = this.findDefinitions(block);
+      this.definitions = {
+        ...this.definitions,
+        ...newDefinitions
+      };
+    }
+  }
+  /**
+   * 从 block 中提取 definitions
+   *
+   * @param block 解析块
+   * @returns Definition 映射表
+   */
+  findDefinitions(block) {
+    const definitions = collectAstNodes(block.node, isDefinitionNode);
+    return definitions.reduce((acc, node) => {
+      acc[node.identifier] = node;
+      return acc;
+    }, {});
+  }
+  /**
+   * 获取所有 definitions
+   *
+   * @returns Definition 映射表
+   */
+  getAll() {
+    return this.definitions;
+  }
+  /**
+   * 清空所有 definitions
+   */
+  clear() {
+    this.definitions = {};
+  }
+};
+
+// src/parser/manager/FootnoteManager.ts
+var FootnoteManager = class {
+  definitions = {};
+  /** 已完成部分的脚注引用顺序（缓存） */
+  completedReferenceOrder = [];
+  /** 所有脚注引用顺序（包括 pending 部分） */
+  referenceOrder = [];
+  /**
+   * 从已完成的 blocks 中提取 footnote definitions
+   *
+   * @param blocks 已完成的块
+   */
+  extractDefinitionsFromBlocks(blocks) {
+    for (const block of blocks) {
+      const newDefinitions = this.findFootnoteDefinitions(block);
+      this.definitions = {
+        ...this.definitions,
+        ...newDefinitions
+      };
+    }
+  }
+  /**
+   * 从 block 中提取 footnote definitions
+   *
+   * @param block 解析块
+   * @returns Footnote Definition 映射表
+   */
+  findFootnoteDefinitions(block) {
+    const definitions = collectAstNodes(block.node, isFootnoteDefinitionNode);
+    return definitions.reduce((acc, node) => {
+      acc[node.identifier] = node;
+      return acc;
+    }, {});
+  }
+  /**
+   * 从已完成的 blocks 中收集脚注引用（增量更新）
+   * 只收集新完成的 blocks 中的引用，并缓存结果
+   *
+   * @param blocks 新完成的 blocks
+   */
+  collectReferencesFromCompletedBlocks(blocks) {
+    const newReferences = /* @__PURE__ */ new Set();
+    blocks.forEach((block) => {
+      traverseAst(block.node, (n) => {
+        if (n.type === "footnoteReference") {
+          const identifier = n.identifier;
+          if (!this.completedReferenceOrder.includes(identifier)) {
+            newReferences.add(identifier);
+          }
+        }
+      });
+    });
+    this.completedReferenceOrder.push(...Array.from(newReferences));
+  }
+  /**
+   * 收集 pending blocks 中的脚注引用
+   * 返回完整的引用顺序（已完成 + pending）
+   *
+   * @param pendingBlocks pending blocks
+   * @returns 完整的脚注引用顺序
+   */
+  collectReferencesFromPending(pendingBlocks) {
+    const pendingReferences = /* @__PURE__ */ new Set();
+    pendingBlocks.forEach((block) => {
+      traverseAst(block.node, (n) => {
+        if (n.type === "footnoteReference") {
+          const identifier = n.identifier;
+          if (!this.completedReferenceOrder.includes(identifier)) {
+            pendingReferences.add(identifier);
+          }
+        }
+      });
+    });
+    this.referenceOrder = [...this.completedReferenceOrder, ...Array.from(pendingReferences)];
+    return this.referenceOrder;
+  }
+  /**
+   * 收集 AST 中的脚注引用（按出现顺序）
+   *
+   * @deprecated 使用 collectReferencesFromCompletedBlocks 和 collectReferencesFromPending 代替
+   * @param nodes AST 节点列表
+   */
+  collectReferences(nodes) {
+    nodes.forEach((node) => {
+      traverseAst(node, (n) => {
+        if (n.type === "footnoteReference") {
+          const identifier = n.identifier;
+          if (!this.referenceOrder.includes(identifier)) {
+            this.referenceOrder.push(identifier);
+          }
+        }
+      });
+    });
+  }
+  /**
+   * 获取所有 footnote definitions
+   *
+   * @returns Footnote Definition 映射表
+   */
+  getDefinitions() {
+    return this.definitions;
+  }
+  /**
+   * 获取脚注引用顺序
+   *
+   * @returns 脚注引用顺序
+   */
+  getReferenceOrder() {
+    return this.referenceOrder;
+  }
+  /**
+   * 清空所有 footnote definitions 和引用顺序
+   */
+  clear() {
+    this.definitions = {};
+    this.completedReferenceOrder = [];
+    this.referenceOrder = [];
+  }
+};
 
 // src/extensions/html-extension/index.ts
 var DEFAULT_TAG_BLACKLIST = [
@@ -294,11 +1031,104 @@ function isHtmlNode(node) {
 function hasChildren(node) {
   return "children" in node && Array.isArray(node.children);
 }
-function processHtmlNodesInArray(nodes, options) {
+function mergeFragmentedHtmlNodes(nodes) {
   const result = [];
   let i = 0;
   while (i < nodes.length) {
     const node = nodes[i];
+    if (!isHtmlNode(node)) {
+      result.push(node);
+      i++;
+      continue;
+    }
+    const unclosedTags = findUnclosedTags(node.value);
+    if (unclosedTags.length === 0) {
+      result.push(node);
+      i++;
+      continue;
+    }
+    const mergedParts = [node.value];
+    let j = i + 1;
+    let currentUnclosed = [...unclosedTags];
+    while (j < nodes.length && currentUnclosed.length > 0) {
+      const nextNode = nodes[j];
+      if (isHtmlNode(nextNode)) {
+        const closingInfo = checkClosingTags(nextNode.value, currentUnclosed);
+        if (closingInfo.hasRelevantClosing) {
+          mergedParts.push(nextNode.value);
+          currentUnclosed = closingInfo.remainingUnclosed;
+          if (currentUnclosed.length === 0) {
+            j++;
+            break;
+          }
+        } else {
+          mergedParts.push(nextNode.value);
+        }
+      } else {
+        break;
+      }
+      j++;
+    }
+    if (mergedParts.length > 1) {
+      const mergedValue = mergedParts.join("\n");
+      const mergedNode = {
+        type: "html",
+        value: mergedValue
+      };
+      result.push(mergedNode);
+      i = j;
+    } else {
+      result.push(node);
+      i++;
+    }
+  }
+  return result;
+}
+function findUnclosedTags(html) {
+  const tagStack = [];
+  const tagRegex = /<\/?([a-zA-Z][a-zA-Z0-9-]*)[^>]*\/?>/g;
+  let match;
+  while ((match = tagRegex.exec(html)) !== null) {
+    const fullTag = match[0];
+    const tagName = match[1].toLowerCase();
+    if (VOID_ELEMENTS.includes(tagName) || fullTag.endsWith("/>")) {
+      continue;
+    }
+    if (fullTag.startsWith("</")) {
+      const lastIndex = tagStack.lastIndexOf(tagName);
+      if (lastIndex !== -1) {
+        tagStack.splice(lastIndex, 1);
+      }
+    } else {
+      tagStack.push(tagName);
+    }
+  }
+  return tagStack;
+}
+function checkClosingTags(html, unclosedTags) {
+  const remaining = [...unclosedTags];
+  let hasRelevant = false;
+  const closeTagRegex = /<\/([a-zA-Z][a-zA-Z0-9-]*)\s*>/g;
+  let match;
+  while ((match = closeTagRegex.exec(html)) !== null) {
+    const tagName = match[1].toLowerCase();
+    const index = remaining.lastIndexOf(tagName);
+    if (index !== -1) {
+      remaining.splice(index, 1);
+      hasRelevant = true;
+    }
+  }
+  return {
+    hasRelevantClosing: hasRelevant,
+    remainingUnclosed: remaining
+  };
+}
+function processHtmlNodesInArray(nodes, options) {
+  const mergedNodes = mergeFragmentedHtmlNodes(nodes);
+  const result = [];
+  let i = 0;
+  while (i < mergedNodes.length) {
+    const node = mergedNodes[i];
     if (isHtmlNode(node)) {
       const contentType = detectHtmlContentType(node.value);
       if (contentType === "fragment") {
@@ -339,8 +1169,8 @@ function processHtmlNodesInArray(nodes, options) {
         let depth = 1;
         let j = i + 1;
         let foundClosing = false;
-        while (j < nodes.length && depth > 0) {
-          const nextNode = nodes[j];
+        while (j < mergedNodes.length && depth > 0) {
+          const nextNode = mergedNodes[j];
           if (isHtmlNode(nextNode)) {
             const nextType = detectHtmlContentType(nextNode.value);
             if (nextType === "closing") {
@@ -403,792 +1233,1057 @@ function transformHtmlNodes(ast, options = {}) {
     children: processHtmlNodesInArray(ast.children, options)
   };
 }
-function createHtmlTreeTransformer(options = {}) {
-  return function transformer(tree) {
-    return transformHtmlNodes(tree, options);
-  };
-}
-var htmlTreeExtension = {
-  enter: {},
-  exit: {}
-};
-function isHtmlElementNode(node) {
-  return node.type === "htmlElement";
-}
-function walkHtmlElements(node, callback, parent = null) {
-  if (isHtmlElementNode(node)) {
-    callback(node, parent);
-  }
-  if (hasChildren(node) || node.type === "root") {
-    const children = node.children;
-    for (const child of children) {
-      walkHtmlElements(child, callback, node);
+
+// src/parser/ast/types.ts
+function extractMarkedExtensions(plugins) {
+  const extensions = [];
+  for (const plugin of plugins) {
+    if ((plugin.type === "marked" || plugin.type === "both") && plugin.marked) {
+      extensions.push(...plugin.marked.extensions);
     }
   }
+  return extensions;
 }
-function findHtmlElementsByTag(root, tagName) {
-  const result = [];
-  walkHtmlElements(root, (node) => {
-    if (node.tagName === tagName.toLowerCase()) {
-      result.push(node);
+
+// src/extensions/marked-extensions/explicitDefinitionExtension.ts
+function createExplicitDefinitionExtension() {
+  return {
+    name: "explicitDefinition",
+    level: "block",
+    // 🔑 关键修复：start 必须匹配完整的 definition 模式 [id]:，
+    // 而不能只匹配 [，否则会把 ![alt][id] 中的 [alt] 误认为是 definition 开头
+    // 同时排除脚注定义 [^id]:
+    start(src) {
+      const match = src.match(/^ {0,3}\[(?!\^)[^\]]+\]:/m);
+      return match?.index;
+    },
+    tokenizer(src) {
+      const rule = /^ {0,3}\[(?!\^)[^\]]+\]:.*?(?:\n+|$)/;
+      const match = rule.exec(src);
+      if (match) {
+        const raw = match[0];
+        const contentMatch = raw.match(
+          /^ {0,3}\[([^\]]+)\]:\s*(\S+)(?:\s+["'(](.*?)["')])?/
+        );
+        if (contentMatch) {
+          const identifier = contentMatch[1].toLowerCase();
+          const url = contentMatch[2];
+          const title = contentMatch[3];
+          if (this.lexer?.tokens?.links) {
+            this.lexer.tokens.links[identifier] = { href: url, title };
+          }
+          return {
+            type: "explicitDefinition",
+            raw,
+            identifier,
+            url,
+            title
+          };
+        }
+        return { type: "explicitDefinition", raw, identifier: "", url: "" };
+      }
+      return void 0;
+    },
+    renderer() {
+      return "";
     }
-  });
-  return result;
+  };
 }
-function htmlElementToString(node) {
-  const { tagName, attrs, children } = node;
-  const attrsStr = Object.entries(attrs).map(([name, value]) => {
-    if (value === "") return name;
-    return `${name}="${escapeHtml(value)}"`;
-  }).join(" ");
-  const openTag = attrsStr ? `<${tagName} ${attrsStr}>` : `<${tagName}>`;
-  if (children.length === 0 && isSelfClosingTag(tagName)) {
-    return attrsStr ? `<${tagName} ${attrsStr} />` : `<${tagName} />`;
-  }
-  const childrenStr = children.map((child) => {
-    if (child.type === "text") {
-      return child.value;
-    }
-    if (isHtmlElementNode(child)) {
-      return htmlElementToString(child);
+
+// src/extensions/marked-extensions/optimisticReferenceExtension.ts
+function createOptimisticReferenceExtension() {
+  return {
+    name: "optimisticReference",
+    level: "inline",
+    start(src) {
+      return src.match(/!?\[/)?.index;
+    },
+    tokenizer(src) {
+      const rule = /^(!?)\[((?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*)\](?:\s*\[((?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*)\])?/;
+      const match = rule.exec(src);
+      if (match) {
+        const fullMatch = match[0];
+        if (src.length > fullMatch.length && src[fullMatch.length] === "(") {
+          return void 0;
+        }
+        if (src.length > fullMatch.length && src[fullMatch.length] === ":") {
+          return void 0;
+        }
+        const isImage = match[1] === "!";
+        const text = match[2];
+        const refRaw = match[3];
+        if (text.startsWith("^")) {
+          return void 0;
+        }
+        let identifier = "";
+        let referenceType = "shortcut";
+        if (refRaw !== void 0) {
+          if (refRaw === "") {
+            referenceType = "collapsed";
+            identifier = text;
+          } else {
+            referenceType = "full";
+            identifier = refRaw;
+          }
+        } else {
+          referenceType = "shortcut";
+          identifier = text;
+          if (text.match(/^[ xX]$/)) {
+            return void 0;
+          }
+        }
+        return {
+          type: "optimisticReference",
+          raw: fullMatch,
+          isImage,
+          text,
+          identifier: identifier.toLowerCase(),
+          label: identifier,
+          referenceType
+        };
+      }
+      return void 0;
+    },
+    renderer() {
+      return "";
     }
-    return "";
-  }).join("");
-  return `${openTag}${childrenStr}</${tagName}>`;
-}
-function isSelfClosingTag(tagName) {
-  return ["br", "hr", "img", "input", "meta", "link", "area", "base", "col", "embed", "source", "track", "wbr"].includes(tagName.toLowerCase());
+  };
 }
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+
+// src/extensions/marked-extensions/mathExtension.ts
+function createBlockMathExtension() {
+  return {
+    name: "blockMath",
+    level: "block",
+    start(src) {
+      const match = src.match(/^ {0,3}\$\$/m);
+      return match?.index;
+    },
+    tokenizer(src) {
+      const rule = /^ {0,3}\$\$([\s\S]*?)\$\$ *(?:\n+|$)/;
+      const match = rule.exec(src);
+      if (match) {
+        return {
+          type: "blockMath",
+          raw: match[0],
+          text: match[1].trim()
+        };
+      }
+      return void 0;
+    },
+    renderer() {
+      return "";
+    }
+  };
 }
-function micromarkReferenceExtension() {
+function createInlineMathExtension() {
   return {
-    // 在 text 中使用 codes.rightSquareBracket 键覆盖 labelEnd
-    text: {
-      [codes.rightSquareBracket]: {
-        name: "labelEnd",
-        resolveAll: resolveAllLabelEnd,
-        resolveTo: resolveToLabelEnd,
-        tokenize: tokenizeLabelEnd,
-        // 添加 add: 'before' 确保先被尝试
-        add: "before"
+    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;
+    },
+    tokenizer(src) {
+      const rule = /^\$(?!\$)((?:\\.|[^\\\n$])+?)\$(?!\d)/;
+      const match = rule.exec(src);
+      if (match) {
+        return {
+          type: "inlineMath",
+          raw: match[0],
+          text: match[1].trim()
+        };
       }
+      return void 0;
+    },
+    renderer() {
+      return "";
     }
   };
 }
-function resolveAllLabelEnd(events) {
-  let index = -1;
-  const newEvents = [];
-  while (++index < events.length) {
-    const token = events[index][1];
-    newEvents.push(events[index]);
-    if (token.type === types.labelImage || token.type === types.labelLink || token.type === types.labelEnd) {
-      const offset = token.type === types.labelImage ? 4 : 2;
-      token.type = types.data;
-      index += offset;
-    }
-  }
-  if (events.length !== newEvents.length) {
-    events.length = 0;
-    events.push(...newEvents);
-  }
-  return events;
-}
-function resolveToLabelEnd(events, context) {
-  let index = events.length;
-  let offset = 0;
-  let token;
-  let open;
-  let close;
-  let media;
-  while (index--) {
-    token = events[index][1];
-    if (open !== void 0) {
-      if (token.type === types.link || token.type === types.labelLink && token._inactive) {
+
+// src/extensions/marked-extensions/footnoteDefinitionExtension.ts
+function createFootnoteDefinitionExtension() {
+  return {
+    name: "footnoteDefinitionBlock",
+    level: "block",
+    start(src) {
+      const match = src.match(/^ {0,3}\[\^[^\]]+\]:/m);
+      return match?.index;
+    },
+    tokenizer(src) {
+      const firstLineRule = /^ {0,3}\[\^([a-zA-Z0-9_-]+)\]:\s*(.*)/;
+      const firstLineMatch = firstLineRule.exec(src);
+      if (!firstLineMatch) return void 0;
+      const identifier = firstLineMatch[1];
+      let content = firstLineMatch[2];
+      let raw = firstLineMatch[0];
+      const remaining = src.slice(raw.length);
+      const lines = remaining.split("\n");
+      let lineIndex = 0;
+      if (lines[0] === "" && remaining.startsWith("\n")) {
+        lineIndex = 1;
+        raw += "\n";
+        content += "\n";
+      }
+      while (lineIndex < lines.length) {
+        const line = lines[lineIndex];
+        if (line.trim() === "") {
+          let hasIndentedLineAfter = false;
+          for (let j = lineIndex + 1; j < lines.length; j++) {
+            const nextLine = lines[j];
+            if (nextLine.trim() === "") continue;
+            if (nextLine.match(/^(    |\t)/)) {
+              hasIndentedLineAfter = true;
+            }
+            break;
+          }
+          if (hasIndentedLineAfter) {
+            raw += line + (lineIndex < lines.length - 1 ? "\n" : "");
+            content += "\n" + line;
+            lineIndex++;
+            continue;
+          } else {
+            break;
+          }
+        }
+        if (line.match(/^(    |\t)/)) {
+          raw += line + (lineIndex < lines.length - 1 ? "\n" : "");
+          content += "\n" + line;
+          lineIndex++;
+          continue;
+        }
+        if (line.match(/^ {0,3}\[\^[^\]]+\]:/)) {
+          break;
+        }
         break;
       }
-      if (events[index][0] === "enter" && token.type === types.labelLink) {
-        token._inactive = true;
+      const trimmedContent = content.replace(/\n+$/, "");
+      return {
+        type: "footnoteDefinitionBlock",
+        raw,
+        identifier,
+        content: trimmedContent
+      };
+    },
+    renderer() {
+      return "";
+    }
+  };
+}
+
+// src/extensions/marked-extensions/inlineHtmlExtension.ts
+var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function createInlineHtmlExtension() {
+  return {
+    name: "inlineHtml",
+    level: "inline",
+    start(src) {
+      const index = src.indexOf("<");
+      if (index === -1) return void 0;
+      const afterLt = src.slice(index + 1);
+      if (!/^[a-zA-Z\/]/.test(afterLt)) return void 0;
+      return index;
+    },
+    tokenizer(src) {
+      const completeTagMatch = matchCompleteHtmlElement(src);
+      if (completeTagMatch) {
+        return {
+          type: "inlineHtml",
+          raw: completeTagMatch,
+          text: completeTagMatch
+        };
       }
-    } else if (close !== void 0) {
-      if (events[index][0] === "enter" && (token.type === types.labelImage || token.type === types.labelLink) && !token._balanced) {
-        open = index;
-        if (token.type !== types.labelLink) {
-          offset = 2;
-          break;
-        }
+      const selfClosingMatch = matchSelfClosingTag(src);
+      if (selfClosingMatch) {
+        return {
+          type: "inlineHtml",
+          raw: selfClosingMatch,
+          text: selfClosingMatch
+        };
       }
-    } else if (token.type === types.labelEnd) {
-      close = index;
+      return void 0;
+    },
+    renderer() {
+      return "";
+    }
+  };
+}
+function matchCompleteHtmlElement(src) {
+  const openTagMatch = /^<([a-zA-Z][a-zA-Z0-9]*)((?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*>/.exec(src);
+  if (!openTagMatch) return null;
+  const tagName = openTagMatch[1].toLowerCase();
+  const openTag = openTagMatch[0];
+  if (SELF_CLOSING_TAGS.has(tagName)) {
+    return openTag;
+  }
+  const afterOpenTag = src.slice(openTag.length);
+  let depth = 1;
+  let pos = 0;
+  const openPattern = new RegExp(`<${tagName}(?:\\s[^>]*)?>`, "gi");
+  const closePattern = new RegExp(`</${tagName}>`, "gi");
+  while (depth > 0 && pos < afterOpenTag.length) {
+    openPattern.lastIndex = pos;
+    closePattern.lastIndex = pos;
+    const nextOpen = openPattern.exec(afterOpenTag);
+    const nextClose = closePattern.exec(afterOpenTag);
+    if (!nextClose) {
+      return null;
     }
+    if (nextOpen && nextOpen.index < nextClose.index) {
+      depth++;
+      pos = nextOpen.index + nextOpen[0].length;
+    } else {
+      depth--;
+      pos = nextClose.index + nextClose[0].length;
+    }
+  }
+  if (depth === 0) {
+    return src.slice(0, openTag.length + pos);
+  }
+  return null;
+}
+function matchSelfClosingTag(src) {
+  const explicitSelfClosing = /^<([a-zA-Z][a-zA-Z0-9]*)((?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*\/>/.exec(src);
+  if (explicitSelfClosing) {
+    return explicitSelfClosing[0];
   }
-  if (open === void 0 || close === void 0) {
-    return events;
+  const implicitSelfClosing = /^<([a-zA-Z][a-zA-Z0-9]*)((?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*>/.exec(src);
+  if (implicitSelfClosing && SELF_CLOSING_TAGS.has(implicitSelfClosing[1].toLowerCase())) {
+    return implicitSelfClosing[0];
   }
-  const group = {
-    type: events[open][1].type === types.labelLink ? types.link : types.image,
-    start: { ...events[open][1].start },
-    end: { ...events[events.length - 1][1].end }
+  return null;
+}
+function transformBlockMath(token) {
+  return {
+    type: "math",
+    value: token.text,
+    meta: null
   };
-  const label = {
-    type: types.label,
-    start: { ...events[open][1].start },
-    end: { ...events[close][1].end }
+}
+function transformFootnoteDefinitionBlock(token, ctx) {
+  const children = ctx.parseFootnoteContent(token.content);
+  return {
+    type: "footnoteDefinition",
+    identifier: token.identifier,
+    label: token.identifier,
+    children
   };
-  const text = {
-    type: types.labelText,
-    start: { ...events[open + offset + 2][1].end },
-    end: { ...events[close - 2][1].start }
+}
+function transformExplicitDefinition(token) {
+  if (!token.identifier || !token.url) return null;
+  return {
+    type: "definition",
+    identifier: token.identifier,
+    label: token.identifier,
+    url: token.url,
+    title: token.title ?? null
   };
-  media = [
-    ["enter", group, context],
-    ["enter", label, context]
-  ];
-  media.push(...events.slice(open + 1, open + offset + 3));
-  media.push(["enter", text, context]);
-  media.push(...events.slice(open + offset + 4, close - 3));
-  media.push(
-    ["exit", text, context],
-    events[close - 2],
-    events[close - 1],
-    ["exit", label, context]
-  );
-  media.push(...events.slice(close + 1));
-  media.push(["exit", group, context]);
-  events.splice(open, events.length - open, ...media);
-  return events;
-}
-function tokenizeLabelEnd(effects, ok, nok) {
-  const self = this;
-  let index = self.events.length;
-  let labelStart;
-  while (index--) {
-    if ((self.events[index][1].type === types.labelImage || self.events[index][1].type === types.labelLink) && !self.events[index][1]._balanced) {
-      labelStart = self.events[index][1];
-      break;
-    }
-  }
-  return start;
-  function start(code) {
-    if (!labelStart) {
-      return nok(code);
-    }
-    if (labelStart._inactive) {
-      return labelEndNok(code);
-    }
-    if (labelStart.type === types.labelLink) {
-      const labelText = self.sliceSerialize({ start: labelStart.end, end: self.now() });
-      if (labelText.startsWith("^")) {
-        return nok(code);
-      }
-    }
-    effects.enter(types.labelEnd);
-    effects.enter(types.labelMarker);
-    effects.consume(code);
-    effects.exit(types.labelMarker);
-    effects.exit(types.labelEnd);
-    return after;
-  }
-  function after(code) {
-    if (code === codes.leftParenthesis) {
-      return effects.attempt(
-        {
-          tokenize: tokenizeResource,
-          partial: false
-        },
-        labelEndOk,
-        labelEndNok
-        // 修复：resource 解析失败时返回 nok
-      )(code);
-    }
-    if (code === codes.leftSquareBracket) {
-      return effects.attempt(
+}
+function transformDef(token) {
+  if (token.tag.startsWith("^")) {
+    const footnoteId = token.tag.slice(1);
+    return {
+      type: "footnoteDefinition",
+      identifier: footnoteId,
+      label: footnoteId,
+      children: [
         {
-          tokenize: tokenizeReferenceFull,
-          partial: false
-        },
-        labelEndOk,
-        referenceNotFull
-        // 修改：即使不是 full reference，也尝试 collapsed
-      )(code);
-    }
-    return labelEndOk(code);
+          type: "paragraph",
+          children: [{ type: "text", value: token.href }]
+        }
+      ]
+    };
+  }
+  return {
+    type: "definition",
+    identifier: token.tag,
+    label: token.tag,
+    url: token.href,
+    title: token.title ?? null
+  };
+}
+function transformContainer(token, ctx) {
+  const attributes = {};
+  const attrRegex = /([a-zA-Z0-9_-]+)=?("([^"]*)"|'([^']*)'|([^ ]*))?/g;
+  let match;
+  while ((match = attrRegex.exec(token.attrs)) !== null) {
+    attributes[match[1]] = match[3] || match[4] || match[5] || "";
+  }
+  const children = ctx.transformTokensWithPosition(token.tokens);
+  return {
+    type: "containerDirective",
+    name: token.name,
+    attributes,
+    children
+  };
+}
+function transformFootnoteDefToken(token, ctx) {
+  return {
+    type: "footnoteDefinition",
+    identifier: token.identifier,
+    label: token.identifier,
+    children: [
+      {
+        type: "paragraph",
+        children: ctx.transformInline(token.tokens)
+      }
+    ]
+  };
+}
+function transformHeading(token, ctx) {
+  return {
+    type: "heading",
+    depth: token.depth,
+    children: ctx.transformInline(token.tokens)
+  };
+}
+function transformParagraph(token, ctx) {
+  return {
+    type: "paragraph",
+    children: ctx.transformInline(token.tokens)
+  };
+}
+function transformCode(token) {
+  return {
+    type: "code",
+    lang: token.lang || null,
+    meta: null,
+    // 对齐 micromark 输出
+    value: token.text
+  };
+}
+function transformBlockquote(token, ctx) {
+  const children = ctx.transformTokens(token.tokens);
+  return {
+    type: "blockquote",
+    children
+  };
+}
+function transformList(token, ctx) {
+  const children = token.items.map((item) => ({
+    type: "listItem",
+    spread: item.loose,
+    checked: item.checked ?? null,
+    // 对齐 micromark 输出（GFM 任务列表）
+    children: ctx.transformTokens(item.tokens)
+  }));
+  return {
+    type: "list",
+    ordered: token.ordered,
+    start: token.ordered ? token.start || 1 : null,
+    // 对齐 micromark：有序列表有 start，无序列表为 null
+    spread: token.loose,
+    children
+  };
+}
+function transformTable(token, ctx) {
+  const headerCells = token.header.map((cell) => ({
+    type: "tableCell",
+    children: ctx.transformInline(cell.tokens)
+  }));
+  const bodyRows = token.rows.map((row) => ({
+    type: "tableRow",
+    children: row.map((cell) => ({
+      type: "tableCell",
+      children: ctx.transformInline(cell.tokens)
+    }))
+  }));
+  return {
+    type: "table",
+    align: token.align,
+    children: [{ type: "tableRow", children: headerCells }, ...bodyRows]
+  };
+}
+function transformHr() {
+  return { type: "thematicBreak" };
+}
+function transformHtml(token) {
+  return {
+    type: "html",
+    value: token.text
+  };
+}
+function transformTextBlock(token, ctx) {
+  if (token.tokens) {
+    return {
+      type: "paragraph",
+      children: ctx.transformInline(token.tokens)
+    };
+  }
+  return {
+    type: "paragraph",
+    children: [{ type: "text", value: token.text }]
+  };
+}
+function transformInlineMath(token) {
+  return {
+    type: "inlineMath",
+    value: token.text
+  };
+}
+function transformOptimisticReference(token, ctx) {
+  if (token.isImage) {
+    return {
+      type: "imageReference",
+      identifier: token.identifier,
+      label: token.label,
+      referenceType: token.referenceType,
+      alt: token.text
+    };
   }
-  function referenceNotFull(code) {
-    return effects.attempt(
-      {
-        tokenize: tokenizeReferenceCollapsed,
-        partial: false
-      },
-      labelEndOk,
-      labelEndOk
-      // 修改：即使失败也返回 ok
-    )(code);
-  }
-  function labelEndOk(code) {
-    return ok(code);
-  }
-  function labelEndNok(code) {
-    labelStart._balanced = true;
-    return nok(code);
-  }
-}
-function tokenizeResource(effects, ok, nok) {
-  return resourceStart;
-  function resourceStart(code) {
-    if (code !== codes.leftParenthesis) {
-      return nok(code);
-    }
-    effects.enter(types.resource);
-    effects.enter(types.resourceMarker);
-    effects.consume(code);
-    effects.exit(types.resourceMarker);
-    return resourceBefore;
-  }
-  function resourceBefore(code) {
-    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);
-  }
-  function resourceOpen(code) {
-    if (code === codes.rightParenthesis) {
-      return resourceEnd(code);
-    }
-    return factoryDestination(
-      effects,
-      resourceDestinationAfter,
-      resourceDestinationMissing,
-      types.resourceDestination,
-      types.resourceDestinationLiteral,
-      types.resourceDestinationLiteralMarker,
-      types.resourceDestinationRaw,
-      types.resourceDestinationString,
-      constants.linkResourceDestinationBalanceMax
-    )(code);
-  }
-  function resourceDestinationAfter(code) {
-    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);
-  }
-  function resourceDestinationMissing(code) {
-    return nok(code);
-  }
-  function resourceBetween(code) {
-    if (code === codes.quotationMark || code === codes.apostrophe || code === codes.leftParenthesis) {
-      return factoryTitle(
-        effects,
-        resourceTitleAfter,
-        nok,
-        types.resourceTitle,
-        types.resourceTitleMarker,
-        types.resourceTitleString
-      )(code);
-    }
-    return resourceEnd(code);
-  }
-  function resourceTitleAfter(code) {
-    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);
-  }
-  function resourceEnd(code) {
-    if (code === codes.rightParenthesis) {
-      effects.enter(types.resourceMarker);
-      effects.consume(code);
-      effects.exit(types.resourceMarker);
-      effects.exit(types.resource);
-      return ok;
-    }
-    return nok(code);
-  }
-}
-function tokenizeReferenceFull(effects, ok, nok) {
-  const self = this;
-  return referenceFull;
-  function referenceFull(code) {
-    if (code !== codes.leftSquareBracket) {
-      return nok(code);
-    }
-    return factoryLabel.call(
-      self,
-      effects,
-      referenceFullAfter,
-      referenceFullMissing,
-      types.reference,
-      types.referenceMarker,
-      types.referenceString
-    )(code);
-  }
-  function referenceFullAfter(code) {
-    return ok(code);
-  }
-  function referenceFullMissing(code) {
-    return nok(code);
-  }
-}
-function tokenizeReferenceCollapsed(effects, ok, nok) {
-  return referenceCollapsedStart;
-  function referenceCollapsedStart(code) {
-    if (code !== codes.leftSquareBracket) {
-      return nok(code);
-    }
-    effects.enter(types.reference);
-    effects.enter(types.referenceMarker);
-    effects.consume(code);
-    effects.exit(types.referenceMarker);
-    return referenceCollapsedOpen;
-  }
-  function referenceCollapsedOpen(code) {
-    if (code === codes.rightSquareBracket) {
-      effects.enter(types.referenceMarker);
-      effects.consume(code);
-      effects.exit(types.referenceMarker);
-      effects.exit(types.reference);
-      return ok;
-    }
-    return nok(code);
-  }
-}
-function gfmFootnoteIncremental() {
-  const original = gfmFootnote();
+  const labelChildren = ctx.transformInline(new Lexer().inlineTokens(token.text));
   return {
-    ...original,
-    text: {
-      ...original.text,
-      // 覆盖 text[91] (`[` 的处理) - 这是脚注引用解析的起点
-      [codes.leftSquareBracket]: {
-        ...original.text[codes.leftSquareBracket],
-        tokenize: tokenizeGfmFootnoteCallIncremental
-      },
-      // 覆盖 text[93] (`]` 的处理) - 用于处理 ![^1] 这样的情况
-      [codes.rightSquareBracket]: {
-        ...original.text[codes.rightSquareBracket],
-        tokenize: tokenizePotentialGfmFootnoteCallIncremental
-      }
-    }
+    type: "linkReference",
+    identifier: token.identifier,
+    label: token.label,
+    referenceType: token.referenceType,
+    children: labelChildren.length ? labelChildren : [{ type: "text", value: token.text }]
   };
 }
-function tokenizeGfmFootnoteCallIncremental(effects, ok, nok) {
-  let size = 0;
-  let data = false;
-  return start;
-  function start(code) {
-    if (code !== codes.leftSquareBracket) {
-      return nok(code);
-    }
-    effects.enter("gfmFootnoteCall");
-    effects.enter("gfmFootnoteCallLabelMarker");
-    effects.consume(code);
-    effects.exit("gfmFootnoteCallLabelMarker");
-    return callStart;
-  }
-  function callStart(code) {
-    if (code !== codes.caret) {
-      return nok(code);
-    }
-    effects.enter("gfmFootnoteCallMarker");
-    effects.consume(code);
-    effects.exit("gfmFootnoteCallMarker");
-    effects.enter("gfmFootnoteCallString");
-    const token = effects.enter("chunkString");
-    token.contentType = "string";
-    return callData;
-  }
-  function callData(code) {
-    if (
-      // 太长
-      size > constants.linkReferenceSizeMax || // 右括号但没有数据
-      code === codes.rightSquareBracket && !data || // EOF、换行、空格、制表符、左括号不支持
-      code === codes.eof || code === codes.leftSquareBracket || markdownLineEndingOrSpace(code)
-    ) {
-      return nok(code);
-    }
-    if (code === codes.rightSquareBracket) {
-      effects.exit("chunkString");
-      effects.exit("gfmFootnoteCallString");
-      effects.enter("gfmFootnoteCallLabelMarker");
-      effects.consume(code);
-      effects.exit("gfmFootnoteCallLabelMarker");
-      effects.exit("gfmFootnoteCall");
-      return ok;
-    }
-    if (!markdownLineEndingOrSpace(code)) {
-      data = true;
-    }
-    size++;
-    effects.consume(code);
-    return code === codes.backslash ? callEscape : callData;
-  }
-  function callEscape(code) {
-    if (code === codes.leftSquareBracket || code === codes.backslash || code === codes.rightSquareBracket) {
-      effects.consume(code);
-      size++;
-      return callData;
-    }
-    return callData(code);
-  }
-}
-function tokenizePotentialGfmFootnoteCallIncremental(effects, ok, nok) {
-  const self = this;
-  let index = self.events.length;
-  let labelStart;
-  while (index--) {
-    const token = self.events[index][1];
-    if (token.type === "labelImage") {
-      labelStart = token;
-      break;
-    }
-    if (token.type === "gfmFootnoteCall" || token.type === "labelLink" || token.type === "label" || token.type === "image" || token.type === "link") {
-      break;
-    }
-  }
-  return start;
-  function start(code) {
-    if (code !== codes.rightSquareBracket) {
-      return nok(code);
-    }
-    if (!labelStart || !labelStart._balanced) {
-      return nok(code);
-    }
-    const id = normalizeIdentifier(
-      self.sliceSerialize({
-        start: labelStart.end,
-        end: self.now()
-      })
-    );
-    if (id.codePointAt(0) !== codes.caret) {
-      return nok(code);
-    }
-    effects.enter("gfmFootnoteCallLabelMarker");
-    effects.consume(code);
-    effects.exit("gfmFootnoteCallLabelMarker");
-    return ok(code);
+function transformLink(token, ctx) {
+  if (token.text.startsWith("^") && token.text.length > 1) {
+    const footnoteId = token.text.slice(1);
+    return {
+      type: "footnoteReference",
+      identifier: footnoteId,
+      label: footnoteId
+    };
   }
+  return {
+    type: "link",
+    url: token.href,
+    title: token.title || null,
+    // 对齐 micromark 输出
+    children: ctx.transformInline(token.tokens)
+  };
 }
-
-// src/detector/index.ts
-var RE_FENCE_START = /^(\s*)((`{3,})|(~{3,}))/;
-var RE_EMPTY_LINE = /^\s*$/;
-var RE_HEADING = /^#{1,6}\s/;
-var RE_THEMATIC_BREAK = /^(\*{3,}|-{3,}|_{3,})\s*$/;
-var RE_BLOCKQUOTE = /^\s{0,3}>/;
-var RE_HTML_BLOCK_1 = /^\s{0,3}<(script|pre|style|textarea|!--|!DOCTYPE|\?|!\[CDATA\[)/i;
-var RE_HTML_BLOCK_2 = /^\s{0,3}<\/?[a-zA-Z][a-zA-Z0-9-]*(\s|>|$)/;
-var RE_TABLE_DELIMITER = /^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?$/;
-var RE_ESCAPE_SPECIAL = /[.*+?^${}()|[\]\\]/g;
-var RE_FOOTNOTE_DEFINITION = /^\[\^([^\]]+)\]:\s/;
-var RE_FOOTNOTE_CONTINUATION = /^(?:    |\t)/;
-var fenceEndPatternCache = /* @__PURE__ */ new Map();
-var containerPatternCache = /* @__PURE__ */ new Map();
-function detectFenceStart(line) {
-  const match = line.match(RE_FENCE_START);
-  if (match) {
-    const fence = match[2];
-    const char = fence[0];
-    return { char, length: fence.length };
-  }
-  return null;
+function transformImage(token) {
+  return {
+    type: "image",
+    url: token.href,
+    title: token.title || null,
+    // 对齐 micromark 输出
+    alt: token.text
+  };
 }
-function detectFenceEnd(line, context) {
-  if (!context.inFencedCode || !context.fenceChar || !context.fenceLength) {
-    return false;
+function transformText(token) {
+  const results = [];
+  const text = token.text;
+  const footnoteRegex = /\[\^([a-zA-Z0-9_-]+)\]/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = footnoteRegex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      results.push({
+        type: "text",
+        value: text.substring(lastIndex, match.index)
+      });
+    }
+    results.push({
+      type: "footnoteReference",
+      identifier: match[1],
+      label: match[1]
+    });
+    lastIndex = match.index + match[0].length;
   }
-  const cacheKey = `${context.fenceChar}-${context.fenceLength}`;
-  let pattern = fenceEndPatternCache.get(cacheKey);
-  if (!pattern) {
-    pattern = new RegExp(`^\\s{0,3}${context.fenceChar}{${context.fenceLength},}\\s*$`);
-    fenceEndPatternCache.set(cacheKey, pattern);
+  if (lastIndex < text.length) {
+    results.push({
+      type: "text",
+      value: text.substring(lastIndex)
+    });
   }
-  return pattern.test(line);
-}
-function isEmptyLine(line) {
-  return RE_EMPTY_LINE.test(line);
-}
-function isHeading(line) {
-  return RE_HEADING.test(line);
+  return results;
 }
-function isThematicBreak(line) {
-  return RE_THEMATIC_BREAK.test(line.trim());
+function transformStrong(token, ctx) {
+  return {
+    type: "strong",
+    children: ctx.transformInline(token.tokens)
+  };
 }
-function isListItemStart(line) {
-  const hasListMarker = /^(\s*)([-*+]|\d{1,9}[.)])/.test(line);
-  if (!hasListMarker) {
-    return null;
-  }
-  const match = line.match(/^(\s*)([-*+]|\d{1,9}[.)])(.*)/);
-  if (match) {
-    const indent = match[1].length;
-    const marker = match[2];
-    const rest = match[3];
-    if (rest.trim()) {
-      const isOrdered = /^\d{1,9}[.)]/.test(marker);
-      return { ordered: isOrdered, indent };
-    }
-    if (/^\s+$/.test(rest)) {
-      const isOrdered = /^\d{1,9}[.)]/.test(marker);
-      return { ordered: isOrdered, indent };
-    }
-  }
-  return null;
+function transformEmphasis(token, ctx) {
+  return {
+    type: "emphasis",
+    children: ctx.transformInline(token.tokens)
+  };
 }
-function isBlockquoteStart(line) {
-  return RE_BLOCKQUOTE.test(line);
+function transformCodespan(token) {
+  return {
+    type: "inlineCode",
+    value: token.text
+  };
 }
-function isHtmlBlock(line) {
-  return RE_HTML_BLOCK_1.test(line) || RE_HTML_BLOCK_2.test(line);
+function transformBreak() {
+  return { type: "break" };
 }
-function isTableDelimiter(line) {
-  return RE_TABLE_DELIMITER.test(line.trim());
+function transformDelete(token, ctx) {
+  return {
+    type: "delete",
+    children: ctx.transformInline(token.tokens)
+  };
 }
-function isFootnoteDefinitionStart(line) {
-  return RE_FOOTNOTE_DEFINITION.test(line);
+function transformInlineHtml(token) {
+  const parsed = parseHtmlFragment(token.text);
+  if (parsed.length > 0) {
+    return parsed;
+  }
+  return { type: "text", value: token.text };
 }
-function isFootnoteContinuation(line) {
-  return RE_FOOTNOTE_CONTINUATION.test(line);
+function isTokenType(token, type) {
+  return token.type === type;
 }
-function detectContainer(line, config) {
-  const marker = config?.marker || ":";
-  const minLength = config?.minMarkerLength || 3;
-  const cacheKey = `${marker}-${minLength}`;
-  let pattern = containerPatternCache.get(cacheKey);
-  if (!pattern) {
-    const escapedMarker = marker.replace(RE_ESCAPE_SPECIAL, "\\$&");
-    pattern = new RegExp(
-      `^(\\s*)(${escapedMarker}{${minLength},})(?:\\s*(\\w[\\w-]*))?(?:\\{[^}]*\\})?(?:\\s+(.*))?\\s*$`
-    );
-    containerPatternCache.set(cacheKey, pattern);
-  }
-  const match = line.match(pattern);
-  if (!match) {
+var builtinBlockTransformers = {
+  blockMath: (token) => {
+    if (isTokenType(token, "blockMath")) return transformBlockMath(token);
+    return null;
+  },
+  footnoteDefinitionBlock: (token, ctx) => {
+    if (isTokenType(token, "footnoteDefinitionBlock"))
+      return transformFootnoteDefinitionBlock(token, ctx);
+    return null;
+  },
+  explicitDefinition: (token) => {
+    if (isTokenType(token, "explicitDefinition"))
+      return transformExplicitDefinition(token);
+    return null;
+  },
+  def: (token) => {
+    if (isTokenType(token, "def")) return transformDef(token);
+    return null;
+  },
+  container: (token, ctx) => {
+    if (isTokenType(token, "container")) return transformContainer(token, ctx);
+    return null;
+  },
+  footnoteDefinition: (token, ctx) => {
+    if (isTokenType(token, "footnoteDefinition"))
+      return transformFootnoteDefToken(token, ctx);
+    return null;
+  },
+  heading: (token, ctx) => {
+    if (isTokenType(token, "heading")) return transformHeading(token, ctx);
+    return null;
+  },
+  paragraph: (token, ctx) => {
+    if (isTokenType(token, "paragraph")) return transformParagraph(token, ctx);
+    return null;
+  },
+  code: (token) => {
+    if (isTokenType(token, "code")) return transformCode(token);
+    return null;
+  },
+  blockquote: (token, ctx) => {
+    if (isTokenType(token, "blockquote")) return transformBlockquote(token, ctx);
+    return null;
+  },
+  list: (token, ctx) => {
+    if (isTokenType(token, "list")) return transformList(token, ctx);
+    return null;
+  },
+  table: (token, ctx) => {
+    if (isTokenType(token, "table")) return transformTable(token, ctx);
+    return null;
+  },
+  hr: () => transformHr(),
+  html: (token) => {
+    if (isTokenType(token, "html")) return transformHtml(token);
+    return null;
+  },
+  space: () => null,
+  text: (token, ctx) => {
+    if (isTokenType(token, "text")) return transformTextBlock(token, ctx);
     return null;
   }
-  const markerLength = match[2].length;
-  const name = match[3] || "";
-  const isEnd = !name && !match[4];
-  if (!isEnd && config?.allowedNames && config.allowedNames.length > 0) {
-    if (!config.allowedNames.includes(name)) {
-      return null;
-    }
-  }
-  return { name, markerLength, isEnd };
-}
-function detectContainerEnd(line, context, config) {
-  if (!context.inContainer || !context.containerMarkerLength) {
-    return false;
+};
+var builtinInlineTransformers = {
+  inlineMath: (token) => {
+    if (isTokenType(token, "inlineMath")) return transformInlineMath(token);
+    return null;
+  },
+  optimisticReference: (token, ctx) => {
+    if (isTokenType(token, "optimisticReference"))
+      return transformOptimisticReference(token, ctx);
+    return null;
+  },
+  link: (token, ctx) => {
+    if (isTokenType(token, "link")) return transformLink(token, ctx);
+    return null;
+  },
+  image: (token) => {
+    if (isTokenType(token, "image")) return transformImage(token);
+    return null;
+  },
+  text: (token) => {
+    if (isTokenType(token, "text")) return transformText(token);
+    return null;
+  },
+  escape: (token) => {
+    if (isTokenType(token, "escape")) return transformText(token);
+    return null;
+  },
+  strong: (token, ctx) => {
+    if (isTokenType(token, "strong")) return transformStrong(token, ctx);
+    return null;
+  },
+  em: (token, ctx) => {
+    if (isTokenType(token, "em")) return transformEmphasis(token, ctx);
+    return null;
+  },
+  codespan: (token) => {
+    if (isTokenType(token, "codespan")) return transformCodespan(token);
+    return null;
+  },
+  br: () => transformBreak(),
+  del: (token, ctx) => {
+    if (isTokenType(token, "del")) return transformDelete(token, ctx);
+    return null;
+  },
+  inlineHtml: (token) => {
+    if (isTokenType(token, "inlineHtml")) return transformInlineHtml(token);
+    return null;
   }
-  const result = detectContainer(line, config);
-  if (!result) {
-    return false;
+};
+function transformBlockToken(token, ctx) {
+  const tokenType = token.type;
+  if (ctx.customBlockTransformers?.[tokenType]) {
+    const result = ctx.customBlockTransformers[tokenType](token, ctx);
+    if (result !== void 0) return result;
+  }
+  if (builtinBlockTransformers[tokenType]) {
+    const result = builtinBlockTransformers[tokenType](token, ctx);
+    if (result !== void 0) return result;
+  }
+  if ("text" in token && typeof token.text === "string") {
+    const paragraph = {
+      type: "paragraph",
+      children: [{ type: "text", value: token.text }]
+    };
+    return paragraph;
   }
-  return result.isEnd && result.markerLength >= context.containerMarkerLength;
+  return null;
 }
-function isBlockBoundary(prevLine, currentLine, context) {
-  if (context.inFencedCode) {
-    return detectFenceEnd(currentLine, context);
-  }
-  if (isEmptyLine(prevLine) && !isEmptyLine(currentLine)) {
-    return true;
+function transformInlineToken(token, ctx) {
+  const tokenType = token.type;
+  if (ctx.customInlineTransformers?.[tokenType]) {
+    const result = ctx.customInlineTransformers[tokenType](token, ctx);
+    if (result !== void 0) return result;
   }
-  if (isHeading(currentLine) && !isEmptyLine(prevLine)) {
-    return true;
+  if (builtinInlineTransformers[tokenType]) {
+    const result = builtinInlineTransformers[tokenType](token, ctx);
+    if (result !== void 0) return result;
   }
-  if (isThematicBreak(currentLine)) {
-    return true;
+  if ("text" in token && typeof token.text === "string") {
+    const text = { type: "text", value: token.text };
+    return text;
   }
-  if (detectFenceStart(currentLine)) {
-    return true;
-  }
-  return false;
-}
-function createInitialContext() {
-  return {
-    inFencedCode: false,
-    listDepth: 0,
-    blockquoteDepth: 0,
-    inContainer: false,
-    containerDepth: 0,
-    inList: false,
-    inFootnote: false,
-    footnoteIdentifier: void 0
-  };
+  return null;
 }
-function isListContinuation(line, listIndent) {
-  if (isEmptyLine(line)) {
-    return true;
+
+// src/parser/ast/MarkedAstBuildter.ts
+var MarkedAstBuilder = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.containerConfig = typeof options.containers === "object" ? options.containers : options.containers === true ? {} : void 0;
+    this.htmlTreeOptions = typeof options.htmlTree === "object" ? options.htmlTree : options.htmlTree === true ? {} : void 0;
+    if (options.plugins) {
+      this.userExtensions.push(...extractMarkedExtensions(options.plugins));
+    }
+    if (options.markedExtensions) {
+      this.userExtensions.push(...options.markedExtensions);
+    }
+    this.transformContext = {
+      transformTokens: this.transformTokens.bind(this),
+      transformTokensWithPosition: this.transformTokensWithPosition.bind(this),
+      transformInline: this.transformInline.bind(this),
+      parseFootnoteContent: this.parseFootnoteContent.bind(this)
+    };
   }
-  const contentIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
-  return contentIndent > listIndent;
-}
-function updateContext(line, context, containerConfig) {
-  const newContext = { ...context };
-  const containerCfg = containerConfig === true ? {} : containerConfig === false ? void 0 : containerConfig;
-  if (context.inFencedCode) {
-    if (detectFenceEnd(line, context)) {
-      newContext.inFencedCode = false;
-      newContext.fenceChar = void 0;
-      newContext.fenceLength = void 0;
-    }
-    return newContext;
-  }
-  const fence = detectFenceStart(line);
-  if (fence) {
-    newContext.inFencedCode = true;
-    newContext.fenceChar = fence.char;
-    newContext.fenceLength = fence.length;
-    return newContext;
-  }
-  if (containerCfg !== void 0) {
-    if (context.inContainer) {
-      if (detectContainerEnd(line, context, containerCfg)) {
-        newContext.containerDepth = context.containerDepth - 1;
-        if (newContext.containerDepth === 0) {
-          newContext.inContainer = false;
-          newContext.containerMarkerLength = void 0;
-          newContext.containerName = void 0;
-        }
-        return newContext;
-      }
-      const nested = detectContainer(line, containerCfg);
-      if (nested && !nested.isEnd) {
-        newContext.containerDepth = context.containerDepth + 1;
-        return newContext;
-      }
-      return newContext;
-    } else {
-      const container = detectContainer(line, containerCfg);
-      if (container && !container.isEnd) {
-        newContext.inContainer = true;
-        newContext.containerMarkerLength = container.markerLength;
-        newContext.containerName = container.name;
-        newContext.containerDepth = 1;
-        return newContext;
+  containerConfig;
+  htmlTreeOptions;
+  globalLinks = {};
+  /** 用户传入的 marked 扩展 */
+  userExtensions = [];
+  /** 转换上下文（用于递归转换） */
+  transformContext;
+  parse(text) {
+    const normalizedText = text.replace(/[\u00A0\u200b\u202f]/g, " ");
+    const optimisticRefExt = createOptimisticReferenceExtension();
+    const explicitDefExt = createExplicitDefinitionExtension();
+    const footnoteDefExt = createFootnoteDefinitionExtension();
+    const userBlockExts = [];
+    const userBlockStartExts = [];
+    const userInlineExts = [];
+    const userInlineStartExts = [];
+    for (const ext of this.userExtensions) {
+      if (ext.level === "block") {
+        if (ext.tokenizer) userBlockExts.push(ext.tokenizer);
+        if (ext.start) userBlockStartExts.push(ext.start);
+      } else if (ext.level === "inline") {
+        if (ext.tokenizer) userInlineExts.push(ext.tokenizer);
+        if (ext.start) userInlineStartExts.push(ext.start);
+      }
+    }
+    const blockExts = [
+      footnoteDefExt.tokenizer,
+      explicitDefExt.tokenizer,
+      ...userBlockExts
+    ];
+    const blockStartExts = [
+      footnoteDefExt.start,
+      explicitDefExt.start,
+      ...userBlockStartExts
+    ];
+    const inlineExts = [optimisticRefExt.tokenizer, ...userInlineExts];
+    const inlineStartExts = [optimisticRefExt.start, ...userInlineStartExts];
+    if (this.options.math) {
+      const blockMathExt = createBlockMathExtension();
+      const inlineMathExt = createInlineMathExtension();
+      blockExts.unshift(blockMathExt.tokenizer);
+      blockStartExts.unshift(blockMathExt.start);
+      inlineExts.unshift(inlineMathExt.tokenizer);
+      inlineStartExts.unshift(inlineMathExt.start);
+    }
+    if (this.htmlTreeOptions) {
+      const inlineHtmlExt = createInlineHtmlExtension();
+      inlineExts.unshift(inlineHtmlExt.tokenizer);
+      inlineStartExts.unshift(inlineHtmlExt.start);
+    }
+    const lexerOptions = {
+      gfm: true,
+      breaks: false,
+      // 关闭软换行转 break，与 Micromark 保持一致
+      ...this.options,
+      extensions: {
+        inline: inlineExts,
+        startInline: inlineStartExts,
+        block: blockExts,
+        startBlock: blockStartExts
       }
+    };
+    const lexerInstance = new Lexer(lexerOptions);
+    if (lexerInstance.tokens && lexerInstance.tokens.links) {
+      Object.assign(lexerInstance.tokens.links, this.globalLinks);
     }
+    let tokens = lexerInstance.lex(normalizedText);
+    if (lexerInstance.tokens && lexerInstance.tokens.links) {
+      Object.assign(this.globalLinks, lexerInstance.tokens.links);
+    }
+    tokens = this.preprocessTokens(tokens);
+    let children = this.transformTokensWithPosition(tokens);
+    if (this.htmlTreeOptions) {
+      children = this.processHtmlNodes(children);
+    }
+    return {
+      type: "root",
+      children
+    };
   }
-  if (context.inFootnote && isFootnoteDefinitionStart(line)) {
-    const identifier = line.match(RE_FOOTNOTE_DEFINITION)?.[1];
-    newContext.footnoteIdentifier = identifier;
-    return newContext;
-  }
-  if (!context.inFootnote && isFootnoteDefinitionStart(line)) {
-    const identifier = line.match(RE_FOOTNOTE_DEFINITION)?.[1];
-    newContext.inFootnote = true;
-    newContext.footnoteIdentifier = identifier;
-    return newContext;
-  }
-  const listItem = isListItemStart(line);
-  if (context.inList) {
-    if (context.listMayEnd) {
-      if (listItem) {
-        if (listItem.ordered === context.listOrdered && listItem.indent === context.listIndent) {
-          newContext.listMayEnd = false;
-          return newContext;
+  /**
+   * 预处理 tokens
+   *
+   * 处理容器指令和遗留的脚注定义（从 paragraph 中提取）
+   */
+  preprocessTokens(tokens) {
+    const result = [];
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      if (token.type === "paragraph") {
+        const text = token.text;
+        const footnoteMatch = text.match(/^\[\^([a-zA-Z0-9_-]+)\]:\s+([\s\S]*)$/);
+        if (footnoteMatch) {
+          const defToken = {
+            type: "footnoteDefinition",
+            identifier: footnoteMatch[1],
+            text: footnoteMatch[2],
+            tokens: new Lexer().inlineTokens(footnoteMatch[2]),
+            raw: token.raw
+          };
+          result.push(defToken);
+          i++;
+          continue;
+        }
+        const containerStartMatch = text.match(/^:::(\s*)([a-zA-Z0-9_-]+)(.*?)(\n|$)/);
+        if (containerStartMatch) {
+          const name = containerStartMatch[2];
+          const attrs = containerStartMatch[3].trim();
+          let rawAccumulator = "";
+          let j = i;
+          let depth = 0;
+          let foundEnd = false;
+          let contentRaw = "";
+          while (j < tokens.length) {
+            const currentToken = tokens[j];
+            rawAccumulator += currentToken.raw;
+            const lines = rawAccumulator.split("\n");
+            depth = 0;
+            let startLineIndex = -1;
+            let endLineIndex = -1;
+            for (let k = 0; k < lines.length; k++) {
+              const line = lines[k];
+              if (line.match(/^:::(\s*)([a-zA-Z0-9_-]+)/)) {
+                if (depth === 0 && startLineIndex === -1) startLineIndex = k;
+                depth++;
+              } else if (line.trim() === ":::") {
+                depth--;
+                if (depth === 0) {
+                  endLineIndex = k;
+                  foundEnd = true;
+                  break;
+                }
+              }
+            }
+            if (foundEnd) {
+              const contentLines = lines.slice(startLineIndex + 1, endLineIndex);
+              contentRaw = contentLines.join("\n");
+              const remainingLines = lines.slice(endLineIndex + 1);
+              const remainingText = remainingLines.join("\n");
+              const containerToken = {
+                type: "container",
+                name,
+                attrs,
+                tokens: this.preprocessTokens(lexer(contentRaw)),
+                raw: rawAccumulator
+              };
+              result.push(containerToken);
+              if (remainingText.trim()) {
+                const remainingTokens = this.preprocessTokens(lexer(remainingText));
+                result.push(...remainingTokens);
+              }
+              i = j + 1;
+              break;
+            }
+            j++;
+          }
+          if (foundEnd) continue;
         }
-        newContext.inList = true;
-        newContext.listOrdered = listItem.ordered;
-        newContext.listIndent = listItem.indent;
-        newContext.listMayEnd = false;
-        return newContext;
-      } else if (isListContinuation(line, context.listIndent ?? 0)) {
-        newContext.listMayEnd = isEmptyLine(line);
-        return newContext;
-      } else {
-        newContext.inList = false;
-        newContext.listOrdered = void 0;
-        newContext.listIndent = void 0;
-        newContext.listMayEnd = false;
-        return newContext;
-      }
-    } else {
-      if (listItem) {
-        return newContext;
-      } else if (isEmptyLine(line)) {
-        newContext.listMayEnd = true;
-        return newContext;
-      } else if (isListContinuation(line, context.listIndent ?? 0)) {
-        return newContext;
-      } else {
-        newContext.inList = false;
-        newContext.listOrdered = void 0;
-        newContext.listIndent = void 0;
-        newContext.listMayEnd = false;
-        return newContext;
       }
+      result.push(token);
+      i++;
     }
-  } else {
-    if (listItem) {
-      newContext.inList = true;
-      newContext.listOrdered = listItem.ordered;
-      newContext.listIndent = listItem.indent;
-      newContext.listMayEnd = false;
-      return newContext;
+    return result;
+  }
+  /**
+   * 转换 tokens 为 MDAST 节点（带位置信息）
+   */
+  transformTokensWithPosition(tokens) {
+    if (!tokens) return [];
+    const results = [];
+    let currentOffset = 0;
+    for (const token of tokens) {
+      const rawLength = token.raw?.length ?? 0;
+      const node = transformBlockToken(token, this.transformContext);
+      if (node) {
+        node.position = {
+          start: { line: 0, column: 0, offset: currentOffset },
+          end: { line: 0, column: 0, offset: currentOffset + rawLength }
+        };
+        results.push(node);
+      }
+      currentOffset += rawLength;
     }
+    return results;
   }
-  if (context.inFootnote) {
-    if (isEmptyLine(line)) {
-      return newContext;
-    } else if (isListItemStart(line)) {
-      const listItemInfo = isListItemStart(line);
-      if (listItemInfo.indent === 0) {
-        newContext.inFootnote = false;
-        newContext.footnoteIdentifier = void 0;
-      } else {
-        return newContext;
+  /**
+   * 转换 tokens 为 MDAST 节点（不带位置信息）
+   */
+  transformTokens(tokens) {
+    if (!tokens) return [];
+    return tokens.map((t) => transformBlockToken(t, this.transformContext)).filter(Boolean);
+  }
+  /**
+   * 转换行内 tokens
+   */
+  transformInline(tokens) {
+    if (!tokens) return [];
+    const results = [];
+    for (const token of tokens) {
+      const result = transformInlineToken(token, this.transformContext);
+      if (result) {
+        if (Array.isArray(result)) {
+          results.push(...result);
+        } else {
+          results.push(result);
+        }
       }
-    } else if (isHeading(line)) {
-      newContext.inFootnote = false;
-      newContext.footnoteIdentifier = void 0;
-      return newContext;
-    } else if (detectFenceStart(line)) {
-      newContext.inFootnote = false;
-      newContext.footnoteIdentifier = void 0;
-      return newContext;
-    } else if (isBlockquoteStart(line)) {
-      newContext.inFootnote = false;
-      newContext.footnoteIdentifier = void 0;
-      return newContext;
-    } else if (isFootnoteContinuation(line)) {
-      return newContext;
-    } else if (isFootnoteDefinitionStart(line)) {
-      const identifier = line.match(RE_FOOTNOTE_DEFINITION)?.[1];
-      newContext.footnoteIdentifier = identifier;
-      return newContext;
-    } else {
-      newContext.inFootnote = false;
-      newContext.footnoteIdentifier = void 0;
-      return newContext;
     }
+    return results;
   }
-  return newContext;
-}
-
-// src/utils/index.ts
-var idCounter = 0;
-function generateId(prefix = "block") {
-  return `${prefix}-${++idCounter}`;
-}
-function resetIdCounter() {
-  idCounter = 0;
-}
-function calculateLineOffset(lines, lineIndex) {
-  let offset = 0;
-  for (let i = 0; i < lineIndex && i < lines.length; i++) {
-    offset += lines[i].length + 1;
+  /**
+   * 解析脚注内容为 AST 节点
+   */
+  parseFootnoteContent(content) {
+    if (!content.trim()) {
+      return [];
+    }
+    const normalizedContent = content.split("\n").map((line, index) => {
+      if (index === 0) return line;
+      if (line.startsWith("    ")) return line.slice(4);
+      if (line.startsWith("	")) return line.slice(1);
+      return line;
+    }).join("\n");
+    const contentLexer = new Lexer({ gfm: true, breaks: true });
+    const tokens = contentLexer.lex(normalizedContent);
+    return this.transformTokens(tokens);
   }
-  return offset;
-}
-function splitLines(text) {
-  return text.split("\n");
-}
-function joinLines(lines, start, end) {
-  return lines.slice(start, end + 1).join("\n");
-}
-function isDefinitionNode(node) {
-  return node.type === "definition";
-}
-function isFootnoteDefinitionNode(node) {
-  return node.type === "footnoteDefinition";
-}
+  /**
+   * 处理 HTML 节点
+   *
+   * 使用 html-extension 的 transformHtmlNodes 来处理：
+   * - 合并被空行分割的 HTML 节点
+   * - 将 HTML 解析为 HtmlElementNode 树结构
+   */
+  processHtmlNodes(nodes) {
+    const tempRoot = {
+      type: "root",
+      children: nodes
+    };
+    const transformed = transformHtmlNodes(tempRoot, this.htmlTreeOptions);
+    return transformed.children;
+  }
+  /**
+   * 将 AST 节点转换为 ParsedBlock
+   */
+  nodesToBlocks(nodes, startOffset, rawText, status, generateBlockId) {
+    const blocks = [];
+    for (const node of nodes) {
+      const relativeStart = node.position?.start?.offset ?? 0;
+      const relativeEnd = node.position?.end?.offset ?? rawText.length;
+      const nodeText = rawText.substring(relativeStart, relativeEnd);
+      const absoluteStart = startOffset + relativeStart;
+      const absoluteEnd = startOffset + relativeEnd;
+      blocks.push({
+        id: generateBlockId(),
+        status,
+        node,
+        startOffset: absoluteStart,
+        endOffset: absoluteEnd,
+        rawText: nodeText
+      });
+    }
+    return blocks;
+  }
+};
 
 // src/parser/IncremarkParser.ts
 var IncremarkParser = class {
-  buffer = "";
   lines = [];
   /** 行偏移量前缀和：lineOffsets[i] = 第i行起始位置的偏移量 */
   lineOffsets = [0];
@@ -1197,223 +2292,62 @@ var IncremarkParser = class {
   blockIdCounter = 0;
   context;
   options;
-  /** 缓存的容器配置，避免重复计算 */
-  containerConfig;
-  /** 缓存的 HTML 树配置，避免重复计算 */
-  htmlTreeConfig;
+  /** 边界检测器 */
+  boundaryDetector;
+  /** AST 构建器 */
+  astBuilder;
+  /** Definition 管理器 */
+  definitionManager;
+  /** Footnote 管理器 */
+  footnoteManager;
   /** 上次 append 返回的 pending blocks，用于 getAst 复用 */
   lastPendingBlocks = [];
-  /** Definition 映射表（用于引用式图片和链接） */
-  definitionMap = {};
-  /** Footnote Definition 映射表 */
-  footnoteDefinitionMap = {};
-  /** Footnote Reference 出现顺序（按引用在文档中的顺序） */
-  footnoteReferenceOrder = [];
   constructor(options = {}) {
     this.options = {
       gfm: true,
       ...options
     };
     this.context = createInitialContext();
-    this.containerConfig = this.computeContainerConfig();
-    this.htmlTreeConfig = this.computeHtmlTreeConfig();
+    const BuilderClass = options.astBuilder || MarkedAstBuilder;
+    this.astBuilder = new BuilderClass(this.options);
+    this.boundaryDetector = new BoundaryDetector({ containers: this.astBuilder.containerConfig });
+    this.definitionManager = new DefinitionManager();
+    this.footnoteManager = new FootnoteManager();
   }
   generateBlockId() {
     return `block-${++this.blockIdCounter}`;
   }
-  computeContainerConfig() {
-    const containers = this.options.containers;
-    if (!containers) return void 0;
-    return containers === true ? {} : containers;
-  }
-  computeHtmlTreeConfig() {
-    const htmlTree = this.options.htmlTree;
-    if (!htmlTree) return void 0;
-    return htmlTree === true ? {} : htmlTree;
-  }
   /**
-   * 将 HTML 节点转换为纯文本
-   * 递归处理 AST 中所有 html 类型的节点
-   * - 块级 HTML 节点 → 转换为 paragraph 包含 text
-   * - 内联 HTML 节点（在段落内部）→ 转换为 text 节点
+   * 更新已完成的 blocks 中的 definitions 和 footnote definitions
    */
-  convertHtmlToText(ast) {
-    const processInlineChildren = (children) => {
-      return children.map((node) => {
-        const n = node;
-        if (n.type === "html") {
-          const htmlNode = n;
-          const textNode = {
-            type: "text",
-            value: htmlNode.value,
-            position: htmlNode.position
-          };
-          return textNode;
-        }
-        if ("children" in n && Array.isArray(n.children)) {
-          const parent = n;
-          return {
-            ...parent,
-            children: processInlineChildren(parent.children)
-          };
-        }
-        return n;
-      });
-    };
-    const processBlockChildren = (children) => {
-      return children.map((node) => {
-        if (node.type === "html") {
-          const htmlNode = node;
-          const textNode = {
-            type: "text",
-            value: htmlNode.value
-          };
-          const paragraphNode = {
-            type: "paragraph",
-            children: [textNode],
-            position: htmlNode.position
-          };
-          return paragraphNode;
-        }
-        if ("children" in node && Array.isArray(node.children)) {
-          const parent = node;
-          if (node.type === "paragraph" || node.type === "heading" || node.type === "tableCell" || node.type === "delete" || node.type === "emphasis" || node.type === "strong" || node.type === "link" || node.type === "linkReference") {
-            return {
-              ...parent,
-              children: processInlineChildren(parent.children)
-            };
-          }
-          return {
-            ...parent,
-            children: processBlockChildren(parent.children)
-          };
-        }
-        return node;
-      });
-    };
-    return {
-      ...ast,
-      children: processBlockChildren(ast.children)
-    };
-  }
-  parse(text) {
-    const extensions = [];
-    const mdastExtensions = [];
-    if (this.options.gfm) {
-      extensions.push(gfm());
-      mdastExtensions.push(...gfmFromMarkdown(), gfmFootnoteFromMarkdown());
-    }
-    if (this.options.math) {
-      extensions.push(math());
-      mdastExtensions.push(mathFromMarkdown());
-    }
-    if (this.containerConfig !== void 0) {
-      extensions.push(directive());
-      mdastExtensions.push(directiveFromMarkdown());
-    }
-    if (this.options.extensions) {
-      extensions.push(...this.options.extensions);
-    }
-    if (this.options.mdastExtensions) {
-      mdastExtensions.push(...this.options.mdastExtensions);
-    }
-    if (this.options.gfm) {
-      extensions.push(gfmFootnoteIncremental());
-    }
-    extensions.push(micromarkReferenceExtension());
-    let ast = fromMarkdown(text, { extensions, mdastExtensions });
-    if (this.htmlTreeConfig) {
-      ast = transformHtmlNodes(ast, this.htmlTreeConfig);
-    } else {
-      ast = this.convertHtmlToText(ast);
-    }
-    return ast;
-  }
   updateDefinitionsFromCompletedBlocks(blocks) {
-    for (const block of blocks) {
-      this.definitionMap = {
-        ...this.definitionMap,
-        ...this.findDefinition(block)
-      };
-      this.footnoteDefinitionMap = {
-        ...this.footnoteDefinitionMap,
-        ...this.findFootnoteDefinition(block)
-      };
-    }
-  }
-  findDefinition(block) {
-    const definitions = [];
-    function findDefinitionRecursive(node) {
-      if (isDefinitionNode(node)) {
-        definitions.push(node);
-      }
-      if ("children" in node && Array.isArray(node.children)) {
-        for (const child of node.children) {
-          findDefinitionRecursive(child);
-        }
-      }
-    }
-    findDefinitionRecursive(block.node);
-    return definitions.reduce((acc, node) => {
-      acc[node.identifier] = node;
-      return acc;
-    }, {});
-  }
-  findFootnoteDefinition(block) {
-    const footnoteDefinitions = [];
-    function findFootnoteDefinition(node) {
-      if (isFootnoteDefinitionNode(node)) {
-        footnoteDefinitions.push(node);
-      }
-    }
-    findFootnoteDefinition(block.node);
-    return footnoteDefinitions.reduce((acc, node) => {
-      acc[node.identifier] = node;
-      return acc;
-    }, {});
-  }
-  /**
-   * 收集 AST 中的脚注引用（按出现顺序）
-   * 用于确定脚注的显示顺序
-   */
-  collectFootnoteReferences(nodes) {
-    const visitNode = (node) => {
-      if (!node) return;
-      if (node.type === "footnoteReference") {
-        const identifier = node.identifier;
-        if (!this.footnoteReferenceOrder.includes(identifier)) {
-          this.footnoteReferenceOrder.push(identifier);
-        }
-      }
-      if (node.children && Array.isArray(node.children)) {
-        node.children.forEach(visitNode);
-      }
-    };
-    nodes.forEach(visitNode);
+    this.definitionManager.extractFromBlocks(blocks);
+    this.footnoteManager.extractDefinitionsFromBlocks(blocks);
   }
   /**
    * 增量更新 lines 和 lineOffsets
-   * 只处理新增的内容，避免全量 split
+   * 优化策略：只 split 新增的 chunk，不拼接旧字符串，避免长行性能劣化
    */
-  updateLines() {
+  updateLines(chunk) {
     const prevLineCount = this.lines.length;
     if (prevLineCount === 0) {
-      this.lines = this.buffer.split("\n");
+      this.lines = chunk.split("\n");
       this.lineOffsets = [0];
-      for (let i = 0; i < this.lines.length; i++) {
+      for (let i = 0; i < this.lines.length - 1; i++) {
         this.lineOffsets.push(this.lineOffsets[i] + this.lines[i].length + 1);
       }
       return;
     }
-    const lastLineStart = this.lineOffsets[prevLineCount - 1];
-    const textFromLastLine = this.buffer.slice(lastLineStart);
-    const newLines = textFromLastLine.split("\n");
-    this.lines.length = prevLineCount - 1;
-    this.lineOffsets.length = prevLineCount;
-    for (let i = 0; i < newLines.length; i++) {
-      this.lines.push(newLines[i]);
-      const prevOffset = this.lineOffsets[this.lineOffsets.length - 1];
-      this.lineOffsets.push(prevOffset + newLines[i].length + 1);
+    const chunkLines = chunk.split("\n");
+    const lastLineIndex = prevLineCount - 1;
+    this.lines[lastLineIndex] += chunkLines[0];
+    for (let i = 1; i < chunkLines.length; i++) {
+      const prevLineIndex = this.lines.length - 1;
+      const prevLineStart = this.lineOffsets[prevLineIndex];
+      const prevLineLength = this.lines[prevLineIndex].length;
+      const newOneOffset = prevLineStart + prevLineLength + 1;
+      this.lineOffsets.push(newOneOffset);
+      this.lines.push(chunkLines[i]);
     }
   }
   /**
@@ -1427,176 +2361,18 @@ var IncremarkParser = class {
    * 返回稳定边界行号和该行对应的上下文（用于后续更新，避免重复计算）
    */
   findStableBoundary() {
-    let stableLine = -1;
-    let stableContext = this.context;
-    let tempContext = { ...this.context };
-    for (let i = this.pendingStartLine; i < this.lines.length; i++) {
-      const line = this.lines[i];
-      const wasInFencedCode = tempContext.inFencedCode;
-      const wasInContainer = tempContext.inContainer;
-      const wasContainerDepth = tempContext.containerDepth;
-      tempContext = updateContext(line, tempContext, this.containerConfig);
-      if (wasInFencedCode && !tempContext.inFencedCode) {
-        if (i < this.lines.length - 1) {
-          stableLine = i;
-          stableContext = { ...tempContext };
-        }
-        continue;
-      }
-      if (tempContext.inFencedCode) {
-        continue;
-      }
-      if (wasInContainer && wasContainerDepth === 1 && !tempContext.inContainer) {
-        if (i < this.lines.length - 1) {
-          stableLine = i;
-          stableContext = { ...tempContext };
-        }
-        continue;
-      }
-      if (tempContext.inContainer) {
-        continue;
-      }
-      const stablePoint = this.checkStability(i, tempContext);
-      if (stablePoint >= 0) {
-        stableLine = stablePoint;
-        stableContext = { ...tempContext };
-      }
-    }
-    return { line: stableLine, contextAtLine: stableContext };
-  }
-  checkStability(lineIndex, context) {
-    if (lineIndex === 0) {
-      return -1;
-    }
-    const line = this.lines[lineIndex];
-    const prevLine = this.lines[lineIndex - 1];
-    if (context.inContainer) {
-      if (this.containerConfig !== void 0) {
-        const containerEnd = detectContainerEnd(line, context, this.containerConfig);
-        if (containerEnd) {
-          return lineIndex - 1;
-        }
-      }
-      return -1;
-    }
-    if (context.inList) {
-      if (!context.listMayEnd) {
-        return -1;
-      }
-    }
-    if (isHeading(prevLine) || isThematicBreak(prevLine)) {
-      return lineIndex - 1;
-    }
-    if (lineIndex >= this.lines.length - 1) {
-      return -1;
-    }
-    if (isFootnoteDefinitionStart(prevLine)) {
-      if (isEmptyLine(line) || isFootnoteContinuation(line)) {
-        return -1;
-      }
-      if (isFootnoteDefinitionStart(line)) {
-        return lineIndex - 1;
-      }
-    }
-    if (!isEmptyLine(prevLine) && isFootnoteContinuation(prevLine)) {
-      const footnoteStartLine = this.findFootnoteStart(lineIndex - 1);
-      if (footnoteStartLine >= 0) {
-        if (isEmptyLine(line) || isFootnoteContinuation(line)) {
-          return -1;
-        }
-        if (isFootnoteDefinitionStart(line)) {
-          return lineIndex - 1;
-        }
-        return lineIndex - 1;
-      }
-    }
-    if (!isEmptyLine(prevLine)) {
-      if (isFootnoteDefinitionStart(line) && !isFootnoteDefinitionStart(prevLine)) {
-        return lineIndex - 1;
-      }
-      if (isHeading(line)) {
-        return lineIndex - 1;
-      }
-      if (detectFenceStart(line)) {
-        return lineIndex - 1;
-      }
-      if (isBlockquoteStart(line) && !isBlockquoteStart(prevLine)) {
-        return lineIndex - 1;
-      }
-      if (!context.inList && isListItemStart(line) && !isListItemStart(prevLine)) {
-        return lineIndex - 1;
-      }
-      if (this.containerConfig !== void 0) {
-        const container = detectContainer(line, this.containerConfig);
-        if (container && !container.isEnd) {
-          const prevContainer = detectContainer(prevLine, this.containerConfig);
-          if (!prevContainer || prevContainer.isEnd) {
-            return lineIndex - 1;
-          }
-        }
-      }
-    }
-    if (isEmptyLine(line) && !isEmptyLine(prevLine) && !context.inList) {
-      return lineIndex;
-    }
-    return -1;
-  }
-  /**
-   * 从指定行向上查找脚注定义的起始行
-   * 
-   * @param fromLine 开始查找的行索引
-   * @returns 脚注起始行索引，如果不属于脚注返回 -1
-   * 
-   * @example
-   * // 假设 lines 为:
-   * // 0: "[^1]: 第一行"
-   * // 1: "    第二行"
-   * // 2: "    第三行"
-   * findFootnoteStart(2) // 返回 0
-   * findFootnoteStart(1) // 返回 0
-   */
-  findFootnoteStart(fromLine) {
-    const maxLookback = 20;
-    const startLine = Math.max(0, fromLine - maxLookback);
-    for (let i = fromLine; i >= startLine; i--) {
-      const line = this.lines[i];
-      if (isFootnoteDefinitionStart(line)) {
-        return i;
-      }
-      if (isEmptyLine(line)) {
-        continue;
-      }
-      if (!isFootnoteContinuation(line)) {
-        return -1;
-      }
-    }
-    return -1;
-  }
-  nodesToBlocks(nodes, startOffset, rawText, status) {
-    const blocks = [];
-    let currentOffset = startOffset;
-    for (const node of nodes) {
-      const nodeStart = node.position?.start?.offset ?? currentOffset;
-      const nodeEnd = node.position?.end?.offset ?? currentOffset + 1;
-      const nodeText = rawText.substring(nodeStart - startOffset, nodeEnd - startOffset);
-      blocks.push({
-        id: this.generateBlockId(),
-        status,
-        node,
-        startOffset: nodeStart,
-        endOffset: nodeEnd,
-        rawText: nodeText
-      });
-      currentOffset = nodeEnd;
-    }
-    return blocks;
+    const result = this.boundaryDetector.findStableBoundary(
+      this.lines,
+      this.pendingStartLine,
+      this.context
+    );
+    return { line: result.line, contextAtLine: result.context };
   }
   /**
    * 追加新的 chunk 并返回增量更新
    */
   append(chunk) {
-    this.buffer += chunk;
-    this.updateLines();
+    this.updateLines(chunk);
     const { line: stableBoundary, contextAtLine } = this.findStableBoundary();
     const update = {
       completed: [],
@@ -1610,11 +2386,13 @@ var IncremarkParser = class {
     if (stableBoundary >= this.pendingStartLine && stableBoundary >= 0) {
       const stableText = this.lines.slice(this.pendingStartLine, stableBoundary + 1).join("\n");
       const stableOffset = this.getLineOffset(this.pendingStartLine);
-      const ast = this.parse(stableText);
-      const newBlocks = this.nodesToBlocks(ast.children, stableOffset, stableText, "completed");
+      const ast = this.astBuilder.parse(stableText);
+      const newBlocks = this.astBuilder.nodesToBlocks(ast.children, stableOffset, stableText, "completed", () => this.generateBlockId());
       this.completedBlocks.push(...newBlocks);
       update.completed = newBlocks;
       this.updateDefinitionsFromCompletedBlocks(newBlocks);
+      this.footnoteManager.collectReferencesFromCompletedBlocks(newBlocks);
+      this.boundaryDetector.clearContextCache(this.pendingStartLine);
       this.context = contextAtLine;
       this.pendingStartLine = stableBoundary + 1;
     }
@@ -1622,8 +2400,8 @@ var IncremarkParser = class {
       const pendingText = this.lines.slice(this.pendingStartLine).join("\n");
       if (pendingText.trim()) {
         const pendingOffset = this.getLineOffset(this.pendingStartLine);
-        const ast = this.parse(pendingText);
-        update.pending = this.nodesToBlocks(ast.children, pendingOffset, pendingText, "pending");
+        const ast = this.astBuilder.parse(pendingText);
+        update.pending = this.astBuilder.nodesToBlocks(ast.children, pendingOffset, pendingText, "pending", () => this.generateBlockId());
       }
     }
     this.lastPendingBlocks = update.pending;
@@ -1631,10 +2409,9 @@ var IncremarkParser = class {
       type: "root",
       children: [...this.completedBlocks.map((b) => b.node), ...update.pending.map((b) => b.node)]
     };
-    this.collectFootnoteReferences(update.ast.children);
+    update.footnoteReferenceOrder = this.footnoteManager.collectReferencesFromPending(update.pending);
     update.definitions = this.getDefinitionMap();
     update.footnoteDefinitions = this.getFootnoteDefinitionMap();
-    update.footnoteReferenceOrder = this.getFootnoteReferenceOrder();
     this.emitChange(update.pending);
     return update;
   }
@@ -1646,7 +2423,7 @@ var IncremarkParser = class {
       const state = {
         completedBlocks: this.completedBlocks,
         pendingBlocks,
-        markdown: this.buffer,
+        markdown: this.lines.join("\n"),
         ast: {
           type: "root",
           children: [
@@ -1654,8 +2431,8 @@ var IncremarkParser = class {
             ...pendingBlocks.map((b) => b.node)
           ]
         },
-        definitions: { ...this.definitionMap },
-        footnoteDefinitions: { ...this.footnoteDefinitionMap }
+        definitions: { ...this.getDefinitionMap() },
+        footnoteDefinitions: { ...this.getFootnoteDefinitionMap() }
       };
       this.options.onChange(state);
     }
@@ -1670,24 +2447,27 @@ var IncremarkParser = class {
       updated: [],
       pending: [],
       ast: { type: "root", children: [] },
-      definitions: {},
-      footnoteDefinitions: {},
-      footnoteReferenceOrder: []
+      definitions: this.getDefinitionMap(),
+      footnoteDefinitions: this.getFootnoteDefinitionMap(),
+      footnoteReferenceOrder: this.getFootnoteReferenceOrder()
     };
     if (this.pendingStartLine < this.lines.length) {
       const remainingText = this.lines.slice(this.pendingStartLine).join("\n");
       if (remainingText.trim()) {
         const remainingOffset = this.getLineOffset(this.pendingStartLine);
-        const ast = this.parse(remainingText);
-        const finalBlocks = this.nodesToBlocks(
+        const ast = this.astBuilder.parse(remainingText);
+        const finalBlocks = this.astBuilder.nodesToBlocks(
           ast.children,
           remainingOffset,
           remainingText,
-          "completed"
+          "completed",
+          () => this.generateBlockId()
         );
         this.completedBlocks.push(...finalBlocks);
         update.completed = finalBlocks;
         this.updateDefinitionsFromCompletedBlocks(finalBlocks);
+        this.footnoteManager.collectReferencesFromCompletedBlocks(finalBlocks);
+        this.boundaryDetector.clearContextCache(this.pendingStartLine);
       }
     }
     this.lastPendingBlocks = [];
@@ -1696,7 +2476,6 @@ var IncremarkParser = class {
       type: "root",
       children: this.completedBlocks.map((b) => b.node)
     };
-    this.collectFootnoteReferences(update.ast.children);
     update.definitions = this.getDefinitionMap();
     update.footnoteDefinitions = this.getFootnoteDefinitionMap();
     update.footnoteReferenceOrder = this.getFootnoteReferenceOrder();
@@ -1719,7 +2498,7 @@ var IncremarkParser = class {
       ...this.completedBlocks.map((b) => b.node),
       ...this.lastPendingBlocks.map((b) => b.node)
     ];
-    this.collectFootnoteReferences(children);
+    this.footnoteManager.collectReferencesFromPending(this.lastPendingBlocks);
     return {
       type: "root",
       children
@@ -1735,25 +2514,25 @@ var IncremarkParser = class {
    * 获取当前缓冲区内容
    */
   getBuffer() {
-    return this.buffer;
+    return this.lines.join("\n");
   }
   /**
    * 获取 Definition 映射表（用于引用式图片和链接）
    */
   getDefinitionMap() {
-    return { ...this.definitionMap };
+    return this.definitionManager.getAll();
   }
   /**
    * 获取 Footnote Definition 映射表
    */
   getFootnoteDefinitionMap() {
-    return { ...this.footnoteDefinitionMap };
+    return this.footnoteManager.getDefinitions();
   }
   /**
    * 获取脚注引用的出现顺序
    */
   getFootnoteReferenceOrder() {
-    return [...this.footnoteReferenceOrder];
+    return this.footnoteManager.getReferenceOrder();
   }
   /**
    * 设置状态变化回调（用于 DevTools 等）
@@ -1769,7 +2548,6 @@ var IncremarkParser = class {
    * 重置解析器状态
    */
   reset() {
-    this.buffer = "";
     this.lines = [];
     this.lineOffsets = [0];
     this.completedBlocks = [];
@@ -1777,9 +2555,8 @@ var IncremarkParser = class {
     this.blockIdCounter = 0;
     this.context = createInitialContext();
     this.lastPendingBlocks = [];
-    this.definitionMap = {};
-    this.footnoteDefinitionMap = {};
-    this.footnoteReferenceOrder = [];
+    this.definitionManager.clear();
+    this.footnoteManager.clear();
     this.emitChange([]);
   }
   /**
@@ -1814,10 +2591,9 @@ function countCharsInNode(n) {
   }
   return 1;
 }
-function sliceAst(node, maxChars, accumulatedChunks, skipChars = 0) {
+function sliceAst(node, maxChars, accumulatedChunks) {
   if (maxChars <= 0) return null;
-  if (skipChars >= maxChars) return null;
-  let remaining = maxChars - skipChars;
+  let remaining = maxChars;
   let charIndex = 0;
   const chunkRanges = [];
   if (accumulatedChunks && accumulatedChunks.chunks.length > 0) {
@@ -1836,16 +2612,10 @@ function sliceAst(node, maxChars, accumulatedChunks, skipChars = 0) {
     if (n.value && typeof n.value === "string") {
       const nodeStart = charIndex;
       const nodeEnd = charIndex + n.value.length;
-      if (nodeEnd <= skipChars) {
-        charIndex = nodeEnd;
-        return null;
-      }
-      const skipInNode = Math.max(0, skipChars - nodeStart);
-      const take = Math.min(n.value.length - skipInNode, remaining);
+      const take = Math.min(n.value.length, remaining);
       remaining -= take;
-      if (take === 0) return null;
-      const slicedValue = n.value.slice(skipInNode, skipInNode + take);
       charIndex = nodeEnd;
+      const slicedValue = n.value.slice(0, take);
       const result = {
         ...n,
         value: slicedValue
@@ -1854,11 +2624,11 @@ function sliceAst(node, maxChars, accumulatedChunks, skipChars = 0) {
         const nodeChunks = [];
         let firstChunkLocalStart = take;
         for (const range of chunkRanges) {
-          const overlapStart = Math.max(range.start, nodeStart + skipInNode);
-          const overlapEnd = Math.min(range.end, nodeStart + skipInNode + take);
+          const overlapStart = Math.max(range.start, nodeStart);
+          const overlapEnd = Math.min(range.end, nodeStart + take);
           if (overlapStart < overlapEnd) {
-            const localStart = overlapStart - (nodeStart + skipInNode);
-            const localEnd = overlapEnd - (nodeStart + skipInNode);
+            const localStart = overlapStart - nodeStart;
+            const localEnd = overlapEnd - nodeStart;
             const chunkText = slicedValue.slice(localStart, localEnd);
             if (chunkText.length > 0) {
               if (nodeChunks.length === 0) {
@@ -1880,24 +2650,12 @@ function sliceAst(node, maxChars, accumulatedChunks, skipChars = 0) {
     }
     if (n.children && Array.isArray(n.children)) {
       const newChildren = [];
-      let childCharIndex = charIndex;
       for (const child of n.children) {
         if (remaining <= 0) break;
-        const childChars = countCharsInNode(child);
-        const childStart = childCharIndex;
-        const childEnd = childCharIndex + childChars;
-        if (childEnd <= skipChars) {
-          childCharIndex = childEnd;
-          continue;
-        }
-        const savedCharIndex = charIndex;
-        charIndex = childStart;
         const processed = process(child);
-        charIndex = savedCharIndex;
         if (processed) {
           newChildren.push(processed);
         }
-        childCharIndex = childEnd;
       }
       if (newChildren.length === 0) {
         return null;
@@ -1910,10 +2668,7 @@ function sliceAst(node, maxChars, accumulatedChunks, skipChars = 0) {
   }
   return process(node);
 }
-function appendToAst(baseNode, sourceNode, startChars, endChars, accumulatedChunks) {
-  if (endChars <= startChars) {
-    return baseNode;
-  }
+function appendToAst(baseNode, sourceNode, endChars, accumulatedChunks) {
   const fullSlice = sliceAst(sourceNode, endChars, accumulatedChunks);
   if (!fullSlice) {
     return baseNode;
@@ -2438,7 +3193,6 @@ var BlockTransformer = class {
       this.cachedDisplayNode = appendToAst(
         this.cachedDisplayNode,
         block.node,
-        this.cachedProgress,
         currentProgress,
         this.getAccumulatedChunks()
       );
@@ -2554,51 +3308,7 @@ function createPlugin(name, matcher, options = {}) {
     ...options
   };
 }
-/**
- * @file Micromark 扩展：支持增量解析的 Reference 语法
- * 
- * @description
- * 在增量解析场景中，引用式图片/链接（如 `![Alt][id]`）可能在定义（`[id]: url`）之前出现。
- * 标准 micromark 会检查 parser.defined，如果 id 未定义就解析为文本。
- * 
- * 本扩展通过覆盖 labelEnd 构造，移除 parser.defined 检查，
- * 使得 reference 语法总是被解析为 reference token，
- * 由渲染层根据实际的 definitionMap 决定如何渲染。
- * 
- * @module micromark-reference-extension
- * 
- * @features
- * - ✅ 支持所有 resource 语法（带 title 的图片/链接）
- * - ✅ 支持所有 reference 语法（full, collapsed, shortcut）
- * - ✅ 延迟验证：解析时不检查定义是否存在
- * - ✅ 使用官方 factory 函数，保证与 CommonMark 标准一致
- * 
- * @dependencies
- * - micromark-factory-destination: 解析 URL（支持尖括号、括号平衡）
- * - micromark-factory-title: 解析 title（支持三种引号，支持多行）
- * - micromark-factory-label: 解析 label（支持转义、长度限制）
- * - micromark-factory-whitespace: 解析空白符（正确生成 lineEnding/linePrefix token）
- * - micromark-util-character: 字符判断工具
- * - micromark-util-symbol: 常量（codes, types, constants）
- * - micromark-util-types: TypeScript 类型定义
- * 
- * @see {@link https://github.com/micromark/micromark} - micromark 官方文档
- * @see {@link https://spec.commonmark.org/0.30/#images} - CommonMark 图片规范
- * @see {@link https://spec.commonmark.org/0.30/#links} - CommonMark 链接规范
- * 
- * @example
- * ```typescript
- * import { micromarkReferenceExtension } from './micromark-reference-extension'
- * import { fromMarkdown } from 'mdast-util-from-markdown'
- * 
- * const extensions = [micromarkReferenceExtension()]
- * const ast = fromMarkdown(text, { extensions })
- * ```
- * 
- * @author Incremark Team
- * @license MIT
- */
 
-export { BlockTransformer, DEFAULT_ATTR_BLACKLIST as HTML_ATTR_BLACKLIST, DEFAULT_PROTOCOL_BLACKLIST as HTML_PROTOCOL_BLACKLIST, DEFAULT_TAG_BLACKLIST as HTML_TAG_BLACKLIST, IncremarkParser, allPlugins, calculateLineOffset, cloneNode, codeBlockPlugin, countChars, createBlockTransformer, createHtmlTreeTransformer, createIncremarkParser, createInitialContext, createPlugin, defaultPlugins, detectContainer, detectContainerEnd, detectFenceEnd, detectFenceStart, detectHtmlContentType, findHtmlElementsByTag, generateId, htmlElementToString, htmlTreeExtension, imagePlugin, isBlockBoundary, isBlockquoteStart, isEmptyLine, isHeading, isHtmlBlock, isHtmlElementNode, isListItemStart, isTableDelimiter, isThematicBreak, joinLines, mathPlugin, mermaidPlugin, parseHtmlFragment, parseHtmlTag, resetIdCounter, sliceAst, splitLines, thematicBreakPlugin, transformHtmlNodes, updateContext, walkHtmlElements };
+export { BlockTransformer, IncremarkParser, MarkedAstBuilder, allPlugins, cloneNode, codeBlockPlugin, countChars, createBlockTransformer, createIncremarkParser, createPlugin, defaultPlugins, imagePlugin, mathPlugin, mermaidPlugin, sliceAst, thematicBreakPlugin };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map