@incremark/core 0.2.7 → 0.3.1

package/dist/engines/marked/index.js

@@ -0,0 +1,1608 @@
+import { Lexer, lexer } from 'marked';
+
+// src/parser/ast/MarkedAstBuildter.ts
+
+// src/extensions/html-extension/index.ts
+var DEFAULT_TAG_BLACKLIST = [
+  "script",
+  "style",
+  "iframe",
+  "object",
+  "embed",
+  "form",
+  "input",
+  "button",
+  "textarea",
+  "select",
+  "meta",
+  "link",
+  "base",
+  "frame",
+  "frameset",
+  "applet",
+  "noscript",
+  "template"
+];
+var DEFAULT_ATTR_BLACKLIST = [
+  // 事件属性通过正则匹配
+  "formaction",
+  "xlink:href",
+  "xmlns",
+  "srcdoc"
+];
+var DEFAULT_PROTOCOL_BLACKLIST = [
+  "javascript:",
+  "vbscript:",
+  "data:"
+  // 注意：data:image/ 会被特殊处理允许
+];
+var URL_ATTRS = ["href", "src", "action", "formaction", "poster", "background"];
+var VOID_ELEMENTS = ["br", "hr", "img", "input", "meta", "link", "area", "base", "col", "embed", "source", "track", "wbr"];
+function detectHtmlContentType(html) {
+  const trimmed = html.trim();
+  if (!trimmed) return "unknown";
+  if (!trimmed.startsWith("<")) return "unknown";
+  const closingMatch = trimmed.match(/^<\/([a-zA-Z][a-zA-Z0-9-]*)\s*>$/);
+  if (closingMatch) {
+    return "closing";
+  }
+  const singleTagMatch = trimmed.match(/^<([a-zA-Z][a-zA-Z0-9-]*)(\s[^]*?)?(\/?)>$/);
+  if (singleTagMatch) {
+    const [fullMatch, tagName, attrsString, selfClosingSlash] = singleTagMatch;
+    if (attrsString) {
+      let inQuote = "";
+      let hasUnquotedBracket = false;
+      for (let i = 0; i < attrsString.length; i++) {
+        const char = attrsString[i];
+        if (inQuote) {
+          if (char === inQuote) inQuote = "";
+        } else {
+          if (char === '"' || char === "'") inQuote = char;
+          else if (char === "<") {
+            hasUnquotedBracket = true;
+            break;
+          }
+        }
+      }
+      if (hasUnquotedBracket) {
+        return "fragment";
+      }
+    }
+    const isSelfClosing = selfClosingSlash === "/" || VOID_ELEMENTS.includes(tagName.toLowerCase());
+    return isSelfClosing ? "self-closing" : "opening";
+  }
+  let bracketCount = 0;
+  for (const char of trimmed) {
+    if (char === "<") bracketCount++;
+  }
+  if (bracketCount > 1) {
+    return "fragment";
+  }
+  return "unknown";
+}
+function parseHtmlTag(html) {
+  const trimmed = html.trim();
+  const contentType = detectHtmlContentType(trimmed);
+  if (contentType !== "opening" && contentType !== "closing" && contentType !== "self-closing") {
+    return null;
+  }
+  if (contentType === "closing") {
+    const match2 = trimmed.match(/^<\/([a-zA-Z][a-zA-Z0-9-]*)\s*>$/);
+    if (!match2) return null;
+    return {
+      tagName: match2[1].toLowerCase(),
+      attrs: {},
+      isClosing: true,
+      isSelfClosing: false,
+      rawHtml: html
+    };
+  }
+  const match = trimmed.match(/^<([a-zA-Z][a-zA-Z0-9-]*)(\s[^]*?)?(\/?)>$/);
+  if (!match) return null;
+  const [, tagName, attrsString, selfClosingSlash] = match;
+  const isSelfClosing = selfClosingSlash === "/" || VOID_ELEMENTS.includes(tagName.toLowerCase());
+  const attrs = {};
+  if (attrsString) {
+    const attrRegex = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*(?:=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    let attrMatch;
+    while ((attrMatch = attrRegex.exec(attrsString)) !== null) {
+      const [, name, doubleQuoted, singleQuoted, unquoted] = attrMatch;
+      const value = doubleQuoted ?? singleQuoted ?? unquoted ?? "";
+      attrs[name.toLowerCase()] = decodeHtmlEntities(value);
+    }
+  }
+  return {
+    tagName: tagName.toLowerCase(),
+    attrs,
+    isClosing: false,
+    isSelfClosing,
+    rawHtml: html
+  };
+}
+function decodeHtmlEntities(text) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " "
+  };
+  return text.replace(/&(?:#(\d+)|#x([a-fA-F0-9]+)|([a-zA-Z]+));/g, (match, dec, hex, name) => {
+    if (dec) return String.fromCharCode(parseInt(dec, 10));
+    if (hex) return String.fromCharCode(parseInt(hex, 16));
+    return entities[`&${name};`] || match;
+  });
+}
+function parseTagDirect(tag) {
+  const trimmed = tag.trim();
+  const closingMatch = trimmed.match(/^<\/([a-zA-Z][a-zA-Z0-9-]*)\s*>$/);
+  if (closingMatch) {
+    return {
+      tagName: closingMatch[1].toLowerCase(),
+      attrs: {},
+      isClosing: true,
+      isSelfClosing: false,
+      rawHtml: tag
+    };
+  }
+  const openMatch = trimmed.match(/^<([a-zA-Z][a-zA-Z0-9-]*)([\s\S]*?)(\/?)>$/);
+  if (!openMatch) return null;
+  const [, tagName, attrsString, selfClosingSlash] = openMatch;
+  const isSelfClosing = selfClosingSlash === "/" || VOID_ELEMENTS.includes(tagName.toLowerCase());
+  const attrs = {};
+  if (attrsString) {
+    const attrRegex = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*(?:=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    let attrMatch;
+    while ((attrMatch = attrRegex.exec(attrsString)) !== null) {
+      const [, name, doubleQuoted, singleQuoted, unquoted] = attrMatch;
+      const value = doubleQuoted ?? singleQuoted ?? unquoted ?? "";
+      attrs[name.toLowerCase()] = decodeHtmlEntities(value);
+    }
+  }
+  return {
+    tagName: tagName.toLowerCase(),
+    attrs,
+    isClosing: false,
+    isSelfClosing,
+    rawHtml: tag
+  };
+}
+function parseHtmlFragment(html, options = {}) {
+  const result = [];
+  const stack = [];
+  const tokenRegex = /(<\/?[a-zA-Z][^>]*>)|([^<]+)/g;
+  let match;
+  while ((match = tokenRegex.exec(html)) !== null) {
+    const [, tag, text] = match;
+    if (tag) {
+      const parsed = parseTagDirect(tag);
+      if (!parsed) continue;
+      if (isTagBlacklisted(parsed.tagName, options)) {
+        continue;
+      }
+      if (parsed.isClosing) {
+        let found = false;
+        for (let i = stack.length - 1; i >= 0; i--) {
+          if (stack[i].tagName === parsed.tagName) {
+            const node = stack.pop();
+            if (stack.length > 0) {
+              stack[stack.length - 1].children.push(node);
+            } else {
+              result.push(node);
+            }
+            found = true;
+            break;
+          }
+        }
+        if (!found) continue;
+      } else {
+        const sanitizedAttrs = sanitizeAttrs(parsed.attrs, options);
+        const node = {
+          type: "htmlElement",
+          tagName: parsed.tagName,
+          attrs: sanitizedAttrs,
+          children: [],
+          data: options.preserveRawHtml !== false ? {
+            rawHtml: tag,
+            parsed: true
+          } : void 0
+        };
+        if (parsed.isSelfClosing) {
+          if (stack.length > 0) {
+            stack[stack.length - 1].children.push(node);
+          } else {
+            result.push(node);
+          }
+        } else {
+          stack.push(node);
+        }
+      }
+    } else if (text && text.trim()) {
+      const textNode = {
+        type: "text",
+        value: text
+      };
+      if (stack.length > 0) {
+        stack[stack.length - 1].children.push(textNode);
+      }
+    }
+  }
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (stack.length > 0) {
+      stack[stack.length - 1].children.push(node);
+    } else {
+      result.push(node);
+    }
+  }
+  return result;
+}
+function isTagBlacklisted(tagName, options) {
+  const blacklist = options.tagBlacklist ?? DEFAULT_TAG_BLACKLIST;
+  return blacklist.includes(tagName.toLowerCase());
+}
+function isAttrBlacklisted(attrName, options) {
+  const name = attrName.toLowerCase();
+  const blacklist = options.attrBlacklist ?? DEFAULT_ATTR_BLACKLIST;
+  if (name.startsWith("on")) return true;
+  return blacklist.includes(name);
+}
+function isProtocolDangerous(url, options) {
+  const protocolBlacklist = options.protocolBlacklist ?? DEFAULT_PROTOCOL_BLACKLIST;
+  const normalizedUrl = url.trim().toLowerCase();
+  for (const protocol of protocolBlacklist) {
+    if (normalizedUrl.startsWith(protocol)) {
+      if (protocol === "data:" && normalizedUrl.startsWith("data:image/")) {
+        return false;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function sanitizeAttrs(attrs, options) {
+  const result = {};
+  for (const [name, value] of Object.entries(attrs)) {
+    if (isAttrBlacklisted(name, options)) continue;
+    if (URL_ATTRS.includes(name.toLowerCase())) {
+      if (isProtocolDangerous(value, options)) continue;
+    }
+    result[name] = value;
+  }
+  return result;
+}
+function isHtmlNode(node) {
+  return node.type === "html";
+}
+function hasChildren(node) {
+  return "children" in node && Array.isArray(node.children);
+}
+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") {
+        const fragmentNodes = parseHtmlFragment(node.value, options);
+        if (fragmentNodes.length > 0) {
+          result.push(...fragmentNodes);
+        } else {
+          result.push(node);
+        }
+        i++;
+      } else if (contentType === "self-closing") {
+        const parsed = parseHtmlTag(node.value);
+        if (parsed && !isTagBlacklisted(parsed.tagName, options)) {
+          const elementNode = {
+            type: "htmlElement",
+            tagName: parsed.tagName,
+            attrs: sanitizeAttrs(parsed.attrs, options),
+            children: [],
+            data: options.preserveRawHtml !== false ? {
+              rawHtml: node.value,
+              parsed: true,
+              originalType: "html"
+            } : void 0
+          };
+          result.push(elementNode);
+        }
+        i++;
+      } else if (contentType === "closing") {
+        i++;
+      } else if (contentType === "opening") {
+        const parsed = parseHtmlTag(node.value);
+        if (!parsed || isTagBlacklisted(parsed.tagName, options)) {
+          i++;
+          continue;
+        }
+        const tagName = parsed.tagName;
+        const contentNodes = [];
+        let depth = 1;
+        let j = i + 1;
+        let foundClosing = false;
+        while (j < mergedNodes.length && depth > 0) {
+          const nextNode = mergedNodes[j];
+          if (isHtmlNode(nextNode)) {
+            const nextType = detectHtmlContentType(nextNode.value);
+            if (nextType === "closing") {
+              const nextParsed = parseHtmlTag(nextNode.value);
+              if (nextParsed && nextParsed.tagName === tagName) {
+                depth--;
+                if (depth === 0) {
+                  foundClosing = true;
+                  break;
+                }
+              }
+            } else if (nextType === "opening") {
+              const nextParsed = parseHtmlTag(nextNode.value);
+              if (nextParsed && nextParsed.tagName === tagName) {
+                depth++;
+              }
+            }
+          }
+          contentNodes.push(nextNode);
+          j++;
+        }
+        const elementNode = {
+          type: "htmlElement",
+          tagName: parsed.tagName,
+          attrs: sanitizeAttrs(parsed.attrs, options),
+          children: processHtmlNodesInArray(contentNodes, options),
+          data: options.preserveRawHtml !== false ? {
+            rawHtml: node.value,
+            parsed: true,
+            originalType: "html"
+          } : void 0
+        };
+        result.push(elementNode);
+        i = foundClosing ? j + 1 : j;
+      } else {
+        result.push(node);
+        i++;
+      }
+    } else {
+      if (hasChildren(node)) {
+        const processed = processHtmlNodesInArray(
+          node.children,
+          options
+        );
+        result.push({
+          ...node,
+          children: processed
+        });
+      } else {
+        result.push(node);
+      }
+      i++;
+    }
+  }
+  return result;
+}
+function transformHtmlNodes(ast, options = {}) {
+  return {
+    ...ast,
+    children: processHtmlNodesInArray(ast.children, options)
+  };
+}
+
+// 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 {
+    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 "";
+    }
+  };
+}
+
+// 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 "";
+    }
+  };
+}
+
+// src/extensions/marked-extensions/mathExtension.ts
+function resolveOptions(options) {
+  return {
+    tex: options?.tex ?? false
+  };
+}
+function createBlockMathExtension(options) {
+  const resolved = resolveOptions(options);
+  return {
+    name: "blockMath",
+    level: "block",
+    start(src) {
+      const dollarMatch = src.match(/^ {0,3}\$\$/m);
+      let bracketMatch = null;
+      if (resolved.tex) {
+        bracketMatch = src.match(/^ {0,3}\\\[/m);
+      }
+      if (dollarMatch && bracketMatch) {
+        return Math.min(dollarMatch.index, bracketMatch.index);
+      }
+      return dollarMatch?.index ?? bracketMatch?.index;
+    },
+    tokenizer(src) {
+      const dollarRule = /^ {0,3}\$\$([\s\S]*?)\$\$ *(?:\n+|$)/;
+      const dollarMatch = dollarRule.exec(src);
+      if (dollarMatch) {
+        return {
+          type: "blockMath",
+          raw: dollarMatch[0],
+          text: dollarMatch[1].trim()
+        };
+      }
+      if (resolved.tex) {
+        const bracketRule = /^ {0,3}\\\[([\s\S]*?)\\\] *(?:\n+|$)/;
+        const bracketMatch = bracketRule.exec(src);
+        if (bracketMatch) {
+          return {
+            type: "blockMath",
+            raw: bracketMatch[0],
+            text: bracketMatch[1].trim()
+          };
+        }
+      }
+      return void 0;
+    },
+    renderer() {
+      return "";
+    }
+  };
+}
+function createInlineMathExtension(options) {
+  const resolved = resolveOptions(options);
+  return {
+    name: "inlineMath",
+    level: "inline",
+    start(src) {
+      const dollarIndex = src.indexOf("$");
+      const validDollarIndex = dollarIndex !== -1 && src[dollarIndex + 1] !== "$" ? dollarIndex : -1;
+      let parenIndex = -1;
+      if (resolved.tex) {
+        parenIndex = src.indexOf("\\(");
+      }
+      if (validDollarIndex !== -1 && parenIndex !== -1) {
+        return Math.min(validDollarIndex, parenIndex);
+      }
+      if (validDollarIndex !== -1) return validDollarIndex;
+      if (parenIndex !== -1) return parenIndex;
+      return void 0;
+    },
+    tokenizer(src) {
+      const dollarRule = /^\$(?!\$)((?:\\.|[^\\\n$])+?)\$(?!\d)/;
+      const dollarMatch = dollarRule.exec(src);
+      if (dollarMatch) {
+        return {
+          type: "inlineMath",
+          raw: dollarMatch[0],
+          text: dollarMatch[1].trim()
+        };
+      }
+      if (resolved.tex) {
+        const parenRule = /^\\\(([\s\S]*?)\\\)/;
+        const parenMatch = parenRule.exec(src);
+        if (parenMatch) {
+          return {
+            type: "inlineMath",
+            raw: parenMatch[0],
+            text: parenMatch[1].trim()
+          };
+        }
+      }
+      return void 0;
+    },
+    renderer() {
+      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
+        };
+      }
+      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];
+  }
+  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
+  };
+}
+function transformFootnoteDefinitionBlock(token, ctx) {
+  const children = ctx.parseFootnoteContent(token.content);
+  return {
+    type: "footnoteDefinition",
+    identifier: token.identifier,
+    label: token.identifier,
+    children
+  };
+}
+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
+  };
+}
+function transformDef(token) {
+  if (token.tag.startsWith("^")) {
+    const footnoteId = token.tag.slice(1);
+    return {
+      type: "footnoteDefinition",
+      identifier: footnoteId,
+      label: footnoteId,
+      children: [
+        {
+          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
+    };
+  }
+  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)
+      });
+    }
+    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;
+}
+function transformStrong(token, ctx) {
+  return {
+    type: "strong",
+    children: ctx.transformInline(token.tokens)
+  };
+}
+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;
+  }
+  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;
+  }
+};
+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;
+  }
+};
+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 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 mathOptions = typeof this.options.math === "object" ? this.options.math : {};
+      const blockMathExt = createBlockMathExtension(mathOptions);
+      const inlineMathExt = createInlineMathExtension(mathOptions);
+      blockExts.unshift(blockMathExt.tokenizer);
+      blockStartExts.unshift(blockMathExt.start);
+      inlineExts.unshift(inlineMathExt.tokenizer);
+      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
+    };
+  }
+  /**
+   * 预处理 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;
+        }
+      }
+      result.push(token);
+      i++;
+    }
+    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;
+  }
+  /**
+   * 转换 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);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * 解析脚注内容为 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);
+  }
+  /**
+   * 处理 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;
+  }
+  /**
+   * 更新配置选项
+   * @param options 部分配置选项
+   */
+  updateOptions(options) {
+    Object.assign(this.options, options);
+    if ("containers" in options) {
+      this.containerConfig = typeof options.containers === "object" ? options.containers : options.containers === true ? {} : void 0;
+    }
+    if ("htmlTree" in options) {
+      this.htmlTreeOptions = typeof options.htmlTree === "object" ? options.htmlTree : options.htmlTree === true ? {} : void 0;
+    }
+    if (options.plugins || options.markedExtensions) {
+      this.userExtensions.length = 0;
+      if (options.plugins) {
+        this.userExtensions.push(...extractMarkedExtensions(options.plugins));
+      }
+      if (options.markedExtensions) {
+        this.userExtensions.push(...options.markedExtensions);
+      }
+    }
+  }
+};
+var AstBuilder = MarkedAstBuilder;
+
+// src/engines/marked/index.ts
+function createMarkedBuilder(options = {}) {
+  return new MarkedAstBuilder(options);
+}
+
+export { AstBuilder, MarkedAstBuilder, createMarkedBuilder };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map