@incremark/core 0.2.7 → 0.3.0

package/dist/index.js

@@ -1,19 +1,4 @@
-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 { directive } from 'micromark-extension-directive';
-import { directiveFromMarkdown } from 'mdast-util-directive';
-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 { Lexer, lexer } from 'marked';
 
 // src/detector/index.ts
 var RE_FENCE_START = /^(\s*)((`{3,})|(~{3,}))/;
@@ -458,6 +443,8 @@ var EmptyLineBoundaryChecker = class {
 var BoundaryDetector = class {
   containerConfig;
   checkers;
+  /** 缓存每一行结束时对应的 Context，避免重复计算 */
+  contextCache = /* @__PURE__ */ new Map();
   constructor(config = {}) {
     this.containerConfig = config.containers;
     this.checkers = [
@@ -468,6 +455,17 @@ var BoundaryDetector = class {
       new EmptyLineBoundaryChecker()
     ];
   }
+  /**
+   * 清空上下文缓存
+   * 当 pendingStartLine 推进后调用，释放不再需要的缓存
+   */
+  clearContextCache(beforeLine) {
+    for (const key of this.contextCache.keys()) {
+      if (key < beforeLine) {
+        this.contextCache.delete(key);
+      }
+    }
+  }
   /**
    * 查找稳定边界
    * 返回稳定边界行号和该行对应的上下文（用于后续更新，避免重复计算）
@@ -480,13 +478,14 @@ var BoundaryDetector = class {
   findStableBoundary(lines, startLine, context) {
     let stableLine = -1;
     let stableContext = context;
-    let tempContext = { ...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;
@@ -638,6 +637,9 @@ var DefinitionManager = class {
 // src/parser/manager/FootnoteManager.ts
 var FootnoteManager = class {
   definitions = {};
+  /** 已完成部分的脚注引用顺序（缓存） */
+  completedReferenceOrder = [];
+  /** 所有脚注引用顺序（包括 pending 部分） */
   referenceOrder = [];
   /**
    * 从已完成的 blocks 中提取 footnote definitions
@@ -666,9 +668,52 @@ var FootnoteManager = class {
       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) {
@@ -704,6 +749,7 @@ var FootnoteManager = class {
    */
   clear() {
     this.definitions = {};
+    this.completedReferenceOrder = [];
     this.referenceOrder = [];
   }
 };
@@ -985,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") {
@@ -1030,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") {
@@ -1094,585 +1233,1050 @@ function transformHtmlNodes(ast, options = {}) {
     children: processHtmlNodesInArray(ast.children, options)
   };
 }
-function micromarkReferenceExtension() {
+
+// 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;
+}
+
+// src/extensions/marked-extensions/explicitDefinitionExtension.ts
+function createExplicitDefinitionExtension() {
   return {
-    // 在 text 中使用 codes.rightSquareBracket 键覆盖 labelEnd
-    text: {
-      [codes.rightSquareBracket]: {
-        name: "labelEnd",
-        resolveAll: resolveAllLabelEnd,
-        resolveTo: resolveToLabelEnd,
-        tokenize: tokenizeLabelEnd,
-        // 添加 add: 'before' 确保先被尝试
-        add: "before"
+    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 "";
     }
   };
 }
-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) {
-        break;
+
+// 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
+        };
       }
-      if (events[index][0] === "enter" && token.type === types.labelLink) {
-        token._inactive = true;
+      return void 0;
+    },
+    renderer() {
+      return "";
+    }
+  };
+}
+
+// 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()
+        };
       }
-    } 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;
+      return void 0;
+    },
+    renderer() {
+      return "";
+    }
+  };
+}
+function createInlineMathExtension() {
+  return {
+    name: "inlineMath",
+    level: "inline",
+    start(src) {
+      const index = src.indexOf("$");
+      if (index === -1) return void 0;
+      if (src[index + 1] === "$") return void 0;
+      return index;
+    },
+    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 "";
+    }
+  };
+}
+
+// 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;
+      }
+      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
+        };
+      }
+      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 (open === void 0 || close === void 0) {
-    return events;
+  if (depth === 0) {
+    return src.slice(0, openTag.length + pos);
   }
-  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 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];
+  }
+  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];
+  }
+  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 }]
+        }
+      ]
+    };
   }
-  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();
   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: "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 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);
+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
+    };
+  }
+  const labelChildren = ctx.transformInline(new Lexer().inlineTokens(token.text));
+  return {
+    type: "linkReference",
+    identifier: token.identifier,
+    label: token.label,
+    referenceType: token.referenceType,
+    children: labelChildren.length ? labelChildren : [{ type: "text", value: token.text }]
+  };
+}
+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)
+  };
+}
+function transformImage(token) {
+  return {
+    type: "image",
+    url: token.href,
+    title: token.title || null,
+    // 对齐 micromark 输出
+    alt: token.text
+  };
+}
+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)
+      });
     }
-    effects.enter("gfmFootnoteCallLabelMarker");
-    effects.consume(code);
-    effects.exit("gfmFootnoteCallLabelMarker");
-    return ok(code);
+    results.push({
+      type: "footnoteReference",
+      identifier: match[1],
+      label: match[1]
+    });
+    lastIndex = match.index + match[0].length;
   }
+  if (lastIndex < text.length) {
+    results.push({
+      type: "text",
+      value: text.substring(lastIndex)
+    });
+  }
+  return results;
 }
-
-// src/parser/ast/AstBuilder.ts
-var INLINE_CONTAINER_TYPES = [
-  "paragraph",
-  "heading",
-  "tableCell",
-  "delete",
-  "emphasis",
-  "strong",
-  "link",
-  "linkReference"
-];
-function isInlineContainer(node) {
-  return INLINE_CONTAINER_TYPES.includes(node.type);
+function transformStrong(token, ctx) {
+  return {
+    type: "strong",
+    children: ctx.transformInline(token.tokens)
+  };
 }
-var AstBuilder = class {
-  options;
-  containerConfig;
-  htmlTreeConfig;
-  constructor(options = {}) {
-    this.options = options;
-    this.containerConfig = this.computeContainerConfig(options);
-    this.htmlTreeConfig = this.computeHtmlTreeConfig(options);
+function transformEmphasis(token, ctx) {
+  return {
+    type: "emphasis",
+    children: ctx.transformInline(token.tokens)
+  };
+}
+function transformCodespan(token) {
+  return {
+    type: "inlineCode",
+    value: token.text
+  };
+}
+function transformBreak() {
+  return { type: "break" };
+}
+function transformDelete(token, ctx) {
+  return {
+    type: "delete",
+    children: ctx.transformInline(token.tokens)
+  };
+}
+function transformInlineHtml(token) {
+  const parsed = parseHtmlFragment(token.text);
+  if (parsed.length > 0) {
+    return parsed;
   }
-  /**
-   * 计算容器配置
-   */
-  computeContainerConfig(options) {
-    const containers = options.containers;
-    if (!containers) return void 0;
-    return containers === true ? {} : containers;
+  return { type: "text", value: token.text };
+}
+function isTokenType(token, type) {
+  return token.type === type;
+}
+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;
   }
-  /**
-   * 计算 HTML 树配置
-   */
-  computeHtmlTreeConfig(options) {
-    const htmlTree = options.htmlTree;
-    if (!htmlTree) return void 0;
-    return htmlTree === true ? {} : htmlTree;
+};
+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;
   }
-  /**
-   * 解析文本为 AST
-   *
-   * @param text Markdown 文本
-   * @returns AST
-   */
+};
+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 null;
+}
+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 (builtinInlineTransformers[tokenType]) {
+    const result = builtinInlineTransformers[tokenType](token, ctx);
+    if (result !== void 0) return result;
+  }
+  if ("text" in token && typeof token.text === "string") {
+    const text = { type: "text", value: token.text };
+    return text;
+  }
+  return null;
+}
+
+// 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)
+    };
+  }
+  containerConfig;
+  htmlTreeOptions;
+  globalLinks = {};
+  /** 用户传入的 marked 扩展 */
+  userExtensions = [];
+  /** 转换上下文（用于递归转换） */
+  transformContext;
   parse(text) {
-    const extensions = [];
-    const mdastExtensions = [];
-    if (this.options.gfm) {
-      extensions.push(gfm());
-      mdastExtensions.push(...gfmFromMarkdown(), gfmFootnoteFromMarkdown());
+    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) {
-      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);
+      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);
     }
-    if (this.options.gfm) {
-      extensions.push(gfmFootnoteIncremental());
+    let tokens = lexerInstance.lex(normalizedText);
+    if (lexerInstance.tokens && lexerInstance.tokens.links) {
+      Object.assign(this.globalLinks, lexerInstance.tokens.links);
     }
-    extensions.push(micromarkReferenceExtension());
-    let ast = fromMarkdown(text, { extensions, mdastExtensions });
-    if (this.htmlTreeConfig) {
-      ast = transformHtmlNodes(ast, this.htmlTreeConfig);
-    } else {
-      ast = this.convertHtmlToText(ast);
+    tokens = this.preprocessTokens(tokens);
+    let children = this.transformTokensWithPosition(tokens);
+    if (this.htmlTreeOptions) {
+      children = this.processHtmlNodes(children);
     }
-    return ast;
+    return {
+      type: "root",
+      children
+    };
   }
   /**
-   * 将 HTML 节点转换为纯文本（当未启用 HTML 树转换时）
+   * 预处理 tokens
    *
-   * @param ast AST
-   * @returns 转换后的 AST
+   * 处理容器指令和遗留的脚注定义（从 paragraph 中提取）
    */
-  convertHtmlToText(ast) {
-    return {
-      ...ast,
-      children: this.processBlockChildren(ast.children)
-    };
+  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;
+        }
+      }
+      result.push(token);
+      i++;
+    }
+    return result;
   }
   /**
-   * 处理块级节点
+   * 转换 tokens 为 MDAST 节点（带位置信息）
    */
-  processBlockChildren(children) {
-    return children.map((node) => {
-      if (node.type === "html") {
-        return this.convertBlockHtmlToParagraph(node);
-      }
-      if ("children" in node && Array.isArray(node.children)) {
-        const parent = node;
-        const children2 = isInlineContainer(node) ? this.processInlineChildren(parent.children) : this.processBlockChildren(parent.children);
-        return {
-          ...parent,
-          children: children2
+  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);
       }
-      return node;
-    });
+      currentOffset += rawLength;
+    }
+    return results;
   }
   /**
-   * 处理内联节点
+   * 转换 tokens 为 MDAST 节点（不带位置信息）
    */
-  processInlineChildren(children) {
-    return children.map((node) => {
-      const n = node;
-      if (n.type === "html") {
-        return this.convertInlineHtmlToText(n);
-      }
-      if ("children" in n && Array.isArray(n.children)) {
-        const parent = n;
-        return {
-          ...parent,
-          children: this.processInlineChildren(parent.children)
-        };
+  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);
+        }
       }
-      return n;
-    });
+    }
+    return results;
   }
   /**
-   * 将块级 HTML 节点转换为段落
+   * 解析脚注内容为 AST 节点
    */
-  convertBlockHtmlToParagraph(htmlNode) {
-    const textNode = {
-      type: "text",
-      value: htmlNode.value
-    };
-    const paragraphNode = {
-      type: "paragraph",
-      children: [textNode],
-      position: htmlNode.position
-    };
-    return paragraphNode;
+  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);
   }
   /**
-   * 将内联 HTML 节点转换为纯文本节点
+   * 处理 HTML 节点
+   *
+   * 使用 html-extension 的 transformHtmlNodes 来处理：
+   * - 合并被空行分割的 HTML 节点
+   * - 将 HTML 解析为 HtmlElementNode 树结构
    */
-  convertInlineHtmlToText(htmlNode) {
-    return {
-      type: "text",
-      value: htmlNode.value,
-      position: htmlNode.position
+  processHtmlNodes(nodes) {
+    const tempRoot = {
+      type: "root",
+      children: nodes
     };
+    const transformed = transformHtmlNodes(tempRoot, this.htmlTreeOptions);
+    return transformed.children;
   }
   /**
    * 将 AST 节点转换为 ParsedBlock
-   *
-   * @param nodes AST 节点列表
-   * @param startOffset 起始偏移量
-   * @param rawText 原始文本
-   * @param status 块状态
-   * @param generateBlockId 生成块 ID 的函数
-   * @returns ParsedBlock 列表
    */
   nodesToBlocks(nodes, startOffset, rawText, status, generateBlockId) {
     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);
+      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: nodeStart,
-        endOffset: nodeEnd,
+        startOffset: absoluteStart,
+        endOffset: absoluteEnd,
         rawText: nodeText
       });
-      currentOffset = nodeEnd;
     }
     return blocks;
   }
@@ -1680,7 +2284,6 @@ var AstBuilder = class {
 
 // src/parser/IncremarkParser.ts
 var IncremarkParser = class {
-  buffer = "";
   lines = [];
   /** 行偏移量前缀和：lineOffsets[i] = 第i行起始位置的偏移量 */
   lineOffsets = [0];
@@ -1705,7 +2308,8 @@ var IncremarkParser = class {
       ...options
     };
     this.context = createInitialContext();
-    this.astBuilder = new AstBuilder(this.options);
+    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();
@@ -1720,36 +2324,30 @@ var IncremarkParser = class {
     this.definitionManager.extractFromBlocks(blocks);
     this.footnoteManager.extractDefinitionsFromBlocks(blocks);
   }
-  /**
-   * 收集 AST 中的脚注引用（按出现顺序）
-   * 用于确定脚注的显示顺序
-   */
-  collectFootnoteReferences(nodes) {
-    this.footnoteManager.collectReferences(nodes);
-  }
   /**
    * 增量更新 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]);
     }
   }
   /**
@@ -1774,8 +2372,7 @@ var IncremarkParser = class {
    * 追加新的 chunk 并返回增量更新
    */
   append(chunk) {
-    this.buffer += chunk;
-    this.updateLines();
+    this.updateLines(chunk);
     const { line: stableBoundary, contextAtLine } = this.findStableBoundary();
     const update = {
       completed: [],
@@ -1794,6 +2391,8 @@ var IncremarkParser = class {
       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;
     }
@@ -1810,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;
   }
@@ -1825,7 +2423,7 @@ var IncremarkParser = class {
       const state = {
         completedBlocks: this.completedBlocks,
         pendingBlocks,
-        markdown: this.buffer,
+        markdown: this.lines.join("\n"),
         ast: {
           type: "root",
           children: [
@@ -1868,6 +2466,8 @@ var IncremarkParser = class {
         this.completedBlocks.push(...finalBlocks);
         update.completed = finalBlocks;
         this.updateDefinitionsFromCompletedBlocks(finalBlocks);
+        this.footnoteManager.collectReferencesFromCompletedBlocks(finalBlocks);
+        this.boundaryDetector.clearContextCache(this.pendingStartLine);
       }
     }
     this.lastPendingBlocks = [];
@@ -1876,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();
@@ -1899,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
@@ -1915,7 +2514,7 @@ var IncremarkParser = class {
    * 获取当前缓冲区内容
    */
   getBuffer() {
-    return this.buffer;
+    return this.lines.join("\n");
   }
   /**
    * 获取 Definition 映射表（用于引用式图片和链接）
@@ -1949,7 +2548,6 @@ var IncremarkParser = class {
    * 重置解析器状态
    */
   reset() {
-    this.buffer = "";
     this.lines = [];
     this.lineOffsets = [0];
     this.completedBlocks = [];
@@ -1993,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) {
@@ -2015,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
@@ -2033,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) {
@@ -2059,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;
@@ -2089,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;
@@ -2617,7 +3193,6 @@ var BlockTransformer = class {
       this.cachedDisplayNode = appendToAst(
         this.cachedDisplayNode,
         block.node,
-        this.cachedProgress,
         currentProgress,
         this.getAccumulatedChunks()
       );
@@ -2733,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, IncremarkParser, allPlugins, cloneNode, codeBlockPlugin, countChars, createBlockTransformer, createIncremarkParser, createPlugin, defaultPlugins, imagePlugin, mathPlugin, mermaidPlugin, sliceAst, thematicBreakPlugin };
+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