@incremark/core 0.2.7 → 0.3.1

package/dist/engines/micromark/index.js

@@ -0,0 +1,1667 @@
+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 { mathFromMarkdown } from 'mdast-util-math';
+import { directive } from 'micromark-extension-directive';
+import { directiveFromMarkdown } from 'mdast-util-directive';
+import { codes, types, constants } from 'micromark-util-symbol';
+import { factorySpace } from 'micromark-factory-space';
+import { markdownLineEnding, 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';
+
+// src/parser/ast/MicromarkAstBuilder.ts
+function mathFlow(_options) {
+  return {
+    tokenize: tokenizeMathFenced,
+    concrete: true,
+    name: "mathFlow"
+  };
+}
+var nonLazyContinuation = {
+  tokenize: tokenizeNonLazyContinuation,
+  partial: true
+};
+function tokenizeMathFenced(effects, ok, nok) {
+  const self = this;
+  const tail = self.events[self.events.length - 1];
+  const initialSize = tail && tail[1].type === types.linePrefix ? tail[2].sliceSerialize(tail[1], true).length : 0;
+  let sizeOpen = 0;
+  return start;
+  function start(code) {
+    if (code !== codes.dollarSign) return nok(code);
+    effects.enter("mathFlow");
+    effects.enter("mathFlowFence");
+    effects.enter("mathFlowFenceSequence");
+    return sequenceOpen(code);
+  }
+  function sequenceOpen(code) {
+    if (code === codes.dollarSign) {
+      effects.consume(code);
+      sizeOpen++;
+      return sequenceOpen;
+    }
+    if (sizeOpen < 2) {
+      return nok(code);
+    }
+    effects.exit("mathFlowFenceSequence");
+    return factorySpace(effects, metaBefore, types.whitespace)(code);
+  }
+  function metaBefore(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      return metaAfter(code);
+    }
+    effects.enter("mathFlowFenceMeta");
+    effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+    return meta(code);
+  }
+  function meta(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.chunkString);
+      effects.exit("mathFlowFenceMeta");
+      return metaAfter(code);
+    }
+    if (code === codes.dollarSign) {
+      return nok(code);
+    }
+    effects.consume(code);
+    return meta;
+  }
+  function metaAfter(code) {
+    effects.exit("mathFlowFence");
+    if (self.interrupt) {
+      return ok(code);
+    }
+    return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+  }
+  function beforeNonLazyContinuation(code) {
+    return effects.attempt(
+      { tokenize: tokenizeClosingFence, partial: true },
+      after,
+      contentStart
+    )(code);
+  }
+  function contentStart(code) {
+    return (initialSize ? factorySpace(effects, beforeContentChunk, types.linePrefix, initialSize + 1) : beforeContentChunk)(code);
+  }
+  function beforeContentChunk(code) {
+    if (code === codes.eof) {
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+    }
+    effects.enter("mathFlowValue");
+    return contentChunk(code);
+  }
+  function contentChunk(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit("mathFlowValue");
+      return beforeContentChunk(code);
+    }
+    effects.consume(code);
+    return contentChunk;
+  }
+  function after(code) {
+    effects.exit("mathFlow");
+    return ok(code);
+  }
+  function tokenizeClosingFence(effects2, ok2, nok2) {
+    let size = 0;
+    return factorySpace(
+      effects2,
+      beforeSequenceClose,
+      types.linePrefix,
+      self.parser.constructs.disable?.null?.includes("codeIndented") ? void 0 : constants.tabSize
+    );
+    function beforeSequenceClose(code) {
+      effects2.enter("mathFlowFence");
+      effects2.enter("mathFlowFenceSequence");
+      return sequenceClose(code);
+    }
+    function sequenceClose(code) {
+      if (code === codes.dollarSign) {
+        size++;
+        effects2.consume(code);
+        return sequenceClose;
+      }
+      if (size < sizeOpen) {
+        return nok2(code);
+      }
+      effects2.exit("mathFlowFenceSequence");
+      return factorySpace(effects2, afterSequenceClose, types.whitespace)(code);
+    }
+    function afterSequenceClose(code) {
+      if (code === codes.eof || markdownLineEnding(code)) {
+        effects2.exit("mathFlowFence");
+        return ok2(code);
+      }
+      return nok2(code);
+    }
+  }
+}
+function mathFlowTex(_options) {
+  return {
+    tokenize: tokenizeMathFencedTex,
+    concrete: true,
+    name: "mathFlowTex"
+  };
+}
+function tokenizeMathFencedTex(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    if (code !== codes.backslash) return nok(code);
+    effects.enter("mathFlow");
+    effects.enter("mathFlowFence");
+    effects.enter("mathFlowFenceSequence");
+    effects.consume(code);
+    return afterBackslash;
+  }
+  function afterBackslash(code) {
+    if (code !== codes.leftSquareBracket) {
+      return nok(code);
+    }
+    effects.consume(code);
+    effects.exit("mathFlowFenceSequence");
+    effects.exit("mathFlowFence");
+    if (self.interrupt) {
+      return ok(code);
+    }
+    return contentStart;
+  }
+  function contentStart(code) {
+    if (code === codes.backslash) {
+      return effects.attempt(
+        { tokenize: tokenizeClosingFenceTex, partial: true },
+        afterClose,
+        beginContent
+      )(code);
+    }
+    return beginContent(code);
+  }
+  function beginContent(code) {
+    if (code === codes.eof) {
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      return effects.attempt(nonLazyContinuation, afterLineEnding, after)(code);
+    }
+    effects.enter("mathFlowValue");
+    return contentChunk(code);
+  }
+  function afterLineEnding(code) {
+    return contentStart(code);
+  }
+  function contentChunk(code) {
+    if (code === codes.eof) {
+      effects.exit("mathFlowValue");
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      effects.exit("mathFlowValue");
+      return effects.attempt(nonLazyContinuation, afterLineEnding, after)(code);
+    }
+    if (code === codes.backslash) {
+      effects.exit("mathFlowValue");
+      return effects.attempt(
+        { tokenize: tokenizeClosingFenceTex, partial: true },
+        afterClose,
+        continueContent
+      )(code);
+    }
+    effects.consume(code);
+    return contentChunk;
+  }
+  function continueContent(code) {
+    effects.enter("mathFlowValue");
+    return contentChunk(code);
+  }
+  function afterClose(code) {
+    return after(code);
+  }
+  function after(code) {
+    effects.exit("mathFlow");
+    return ok(code);
+  }
+  function tokenizeClosingFenceTex(effects2, ok2, nok2) {
+    return beforeSequenceClose;
+    function beforeSequenceClose(code) {
+      if (code !== codes.backslash) {
+        return nok2(code);
+      }
+      effects2.enter("mathFlowFence");
+      effects2.enter("mathFlowFenceSequence");
+      effects2.consume(code);
+      return afterBackslashClose;
+    }
+    function afterBackslashClose(code) {
+      if (code !== codes.rightSquareBracket) {
+        return nok2(code);
+      }
+      effects2.consume(code);
+      effects2.exit("mathFlowFenceSequence");
+      effects2.exit("mathFlowFence");
+      return ok2(code);
+    }
+  }
+}
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    if (code === null) {
+      return ok(code);
+    }
+    if (!markdownLineEnding(code)) {
+      return nok(code);
+    }
+    effects.enter(types.lineEnding);
+    effects.consume(code);
+    effects.exit(types.lineEnding);
+    return lineStart;
+  }
+  function lineStart(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+  }
+}
+function mathText(options) {
+  return {
+    tokenize: tokenizeMathText,
+    resolve: resolveMathText,
+    previous: previousDollar,
+    name: "mathText"
+  };
+  function tokenizeMathText(effects, ok, nok) {
+    const self = this;
+    let sizeOpen = 0;
+    let size;
+    let token;
+    return start;
+    function start(code) {
+      if (code !== codes.dollarSign) return nok(code);
+      if (!previousDollar.call(self, self.previous)) return nok(code);
+      effects.enter("mathText");
+      effects.enter("mathTextSequence");
+      return sequenceOpen(code);
+    }
+    function sequenceOpen(code) {
+      if (code === codes.dollarSign) {
+        effects.consume(code);
+        sizeOpen++;
+        return sequenceOpen;
+      }
+      effects.exit("mathTextSequence");
+      return between(code);
+    }
+    function between(code) {
+      if (code === codes.eof) {
+        return nok(code);
+      }
+      if (code === codes.dollarSign) {
+        token = effects.enter("mathTextSequence");
+        size = 0;
+        return sequenceClose(code);
+      }
+      if (code === codes.space) {
+        effects.enter("space");
+        effects.consume(code);
+        effects.exit("space");
+        return between;
+      }
+      if (markdownLineEnding(code)) {
+        effects.enter(types.lineEnding);
+        effects.consume(code);
+        effects.exit(types.lineEnding);
+        return between;
+      }
+      effects.enter("mathTextData");
+      return data(code);
+    }
+    function data(code) {
+      if (code === codes.eof || code === codes.space || code === codes.dollarSign || markdownLineEnding(code)) {
+        effects.exit("mathTextData");
+        return between(code);
+      }
+      effects.consume(code);
+      return data;
+    }
+    function sequenceClose(code) {
+      if (code === codes.dollarSign) {
+        effects.consume(code);
+        size++;
+        return sequenceClose;
+      }
+      if (size === sizeOpen) {
+        effects.exit("mathTextSequence");
+        effects.exit("mathText");
+        return ok(code);
+      }
+      token.type = "mathTextData";
+      return data(code);
+    }
+  }
+}
+function mathTextTex(options) {
+  return {
+    tokenize: tokenizeMathTextTex,
+    resolve: resolveMathText,
+    previous: previousBackslash,
+    name: "mathTextTex"
+  };
+  function tokenizeMathTextTex(effects, ok, nok) {
+    const self = this;
+    return start;
+    function start(code) {
+      if (code !== codes.backslash) return nok(code);
+      if (!previousBackslash.call(self, self.previous)) return nok(code);
+      effects.enter("mathText");
+      effects.enter("mathTextSequence");
+      effects.consume(code);
+      return afterBackslash;
+    }
+    function afterBackslash(code) {
+      if (code !== codes.leftParenthesis) {
+        return nok(code);
+      }
+      effects.consume(code);
+      effects.exit("mathTextSequence");
+      return between;
+    }
+    function between(code) {
+      if (code === codes.eof) {
+        return nok(code);
+      }
+      if (code === codes.backslash) {
+        effects.enter("mathTextSequence");
+        effects.consume(code);
+        return checkClose;
+      }
+      if (code === codes.space) {
+        effects.enter("space");
+        effects.consume(code);
+        effects.exit("space");
+        return between;
+      }
+      if (markdownLineEnding(code)) {
+        effects.enter(types.lineEnding);
+        effects.consume(code);
+        effects.exit(types.lineEnding);
+        return between;
+      }
+      effects.enter("mathTextData");
+      return data(code);
+    }
+    function checkClose(code) {
+      if (code === codes.rightParenthesis) {
+        effects.consume(code);
+        effects.exit("mathTextSequence");
+        effects.exit("mathText");
+        return ok;
+      }
+      effects.exit("mathTextSequence");
+      if (code === codes.backslash || code === codes.space || markdownLineEnding(code) || code === codes.eof) {
+        return between(code);
+      }
+      effects.enter("mathTextData");
+      return data(code);
+    }
+    function data(code) {
+      if (code === codes.eof) {
+        effects.exit("mathTextData");
+        return nok(code);
+      }
+      if (code === codes.backslash) {
+        effects.exit("mathTextData");
+        return between(code);
+      }
+      if (code === codes.space || markdownLineEnding(code)) {
+        effects.exit("mathTextData");
+        return between(code);
+      }
+      effects.consume(code);
+      return data;
+    }
+  }
+}
+var resolveMathText = (events) => {
+  let tailExitIndex = events.length - 4;
+  let headEnterIndex = 3;
+  let index;
+  let enter;
+  if ((events[headEnterIndex][1].type === types.lineEnding || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === types.lineEnding || events[tailExitIndex][1].type === "space")) {
+    index = headEnterIndex;
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === "mathTextData") {
+        events[tailExitIndex][1].type = "mathTextPadding";
+        events[headEnterIndex][1].type = "mathTextPadding";
+        headEnterIndex += 2;
+        tailExitIndex -= 2;
+        break;
+      }
+    }
+  }
+  index = headEnterIndex - 1;
+  tailExitIndex++;
+  while (++index <= tailExitIndex) {
+    if (enter === void 0) {
+      if (index !== tailExitIndex && events[index][1].type !== types.lineEnding) {
+        enter = index;
+      }
+    } else if (index === tailExitIndex || events[index][1].type === types.lineEnding) {
+      events[enter][1].type = "mathTextData";
+      if (index !== enter + 2) {
+        events[enter][1].end = events[index - 1][1].end;
+        events.splice(enter + 2, index - enter - 2);
+        tailExitIndex -= index - enter - 2;
+        index = enter + 2;
+      }
+      enter = void 0;
+    }
+  }
+  return events;
+};
+function previousDollar(code) {
+  return code !== codes.dollarSign || this.events[this.events.length - 1][1].type === types.characterEscape;
+}
+function previousBackslash(code) {
+  return code !== codes.backslash || this.events[this.events.length - 1][1].type === types.characterEscape;
+}
+
+// src/extensions/micromark-extension-math/types.ts
+function resolveMathOptions(options) {
+  return {
+    singleDollarTextMath: options?.singleDollarTextMath,
+    tex: options?.tex ?? false
+  };
+}
+
+// src/extensions/micromark-extension-math/index.ts
+function math(options) {
+  const resolved = resolveMathOptions(options);
+  const extension = {
+    flow: {
+      [codes.dollarSign]: mathFlow()
+    },
+    text: {
+      [codes.dollarSign]: mathText()
+    }
+  };
+  if (resolved.tex) {
+    extension.flow[codes.backslash] = mathFlowTex();
+    extension.text[codes.backslash] = mathTextTex();
+  }
+  return extension;
+}
+
+// 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)
+  };
+}
+function micromarkReferenceExtension() {
+  return {
+    // 在 text 中使用 codes.rightSquareBracket 键覆盖 labelEnd
+    text: {
+      [codes.rightSquareBracket]: {
+        name: "labelEnd",
+        resolveAll: resolveAllLabelEnd,
+        resolveTo: resolveToLabelEnd,
+        tokenize: tokenizeLabelEnd,
+        // 添加 add: 'before' 确保先被尝试
+        add: "before"
+      }
+    }
+  };
+}
+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;
+      }
+      if (events[index][0] === "enter" && token.type === types.labelLink) {
+        token._inactive = true;
+      }
+    } else if (close !== void 0) {
+      if (events[index][0] === "enter" && (token.type === types.labelImage || token.type === types.labelLink) && !token._balanced) {
+        open = index;
+        if (token.type !== types.labelLink) {
+          offset = 2;
+          break;
+        }
+      }
+    } else if (token.type === types.labelEnd) {
+      close = index;
+    }
+  }
+  if (open === void 0 || close === void 0) {
+    return events;
+  }
+  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 }
+  };
+  const label = {
+    type: types.label,
+    start: { ...events[open][1].start },
+    end: { ...events[close][1].end }
+  };
+  const text = {
+    type: types.labelText,
+    start: { ...events[open + offset + 2][1].end },
+    end: { ...events[close - 2][1].start }
+  };
+  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(
+        {
+          tokenize: tokenizeReferenceFull,
+          partial: false
+        },
+        labelEndOk,
+        referenceNotFull
+        // 修改：即使不是 full reference，也尝试 collapsed
+      )(code);
+    }
+    return labelEndOk(code);
+  }
+  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
+      }
+    }
+  };
+}
+function tokenizeGfmFootnoteCallIncremental(effects, ok, nok) {
+  let size = 0;
+  let data = false;
+  return start;
+  function start(code) {
+    if (code !== codes.leftSquareBracket) {
+      return nok(code);
+    }
+    effects.enter("gfmFootnoteCall");
+    effects.enter("gfmFootnoteCallLabelMarker");
+    effects.consume(code);
+    effects.exit("gfmFootnoteCallLabelMarker");
+    return callStart;
+  }
+  function callStart(code) {
+    if (code !== codes.caret) {
+      return nok(code);
+    }
+    effects.enter("gfmFootnoteCallMarker");
+    effects.consume(code);
+    effects.exit("gfmFootnoteCallMarker");
+    effects.enter("gfmFootnoteCallString");
+    const token = effects.enter("chunkString");
+    token.contentType = "string";
+    return callData;
+  }
+  function callData(code) {
+    if (
+      // 太长
+      size > constants.linkReferenceSizeMax || // 右括号但没有数据
+      code === codes.rightSquareBracket && !data || // EOF、换行、空格、制表符、左括号不支持
+      code === codes.eof || code === codes.leftSquareBracket || markdownLineEndingOrSpace(code)
+    ) {
+      return nok(code);
+    }
+    if (code === codes.rightSquareBracket) {
+      effects.exit("chunkString");
+      effects.exit("gfmFootnoteCallString");
+      effects.enter("gfmFootnoteCallLabelMarker");
+      effects.consume(code);
+      effects.exit("gfmFootnoteCallLabelMarker");
+      effects.exit("gfmFootnoteCall");
+      return ok;
+    }
+    if (!markdownLineEndingOrSpace(code)) {
+      data = true;
+    }
+    size++;
+    effects.consume(code);
+    return code === codes.backslash ? callEscape : callData;
+  }
+  function callEscape(code) {
+    if (code === codes.leftSquareBracket || code === codes.backslash || code === codes.rightSquareBracket) {
+      effects.consume(code);
+      size++;
+      return callData;
+    }
+    return callData(code);
+  }
+}
+function tokenizePotentialGfmFootnoteCallIncremental(effects, ok, nok) {
+  const self = this;
+  let index = self.events.length;
+  let labelStart;
+  while (index--) {
+    const token = self.events[index][1];
+    if (token.type === "labelImage") {
+      labelStart = token;
+      break;
+    }
+    if (token.type === "gfmFootnoteCall" || token.type === "labelLink" || token.type === "label" || token.type === "image" || token.type === "link") {
+      break;
+    }
+  }
+  return start;
+  function start(code) {
+    if (code !== codes.rightSquareBracket) {
+      return nok(code);
+    }
+    if (!labelStart || !labelStart._balanced) {
+      return nok(code);
+    }
+    const id = normalizeIdentifier(
+      self.sliceSerialize({
+        start: labelStart.end,
+        end: self.now()
+      })
+    );
+    if (id.codePointAt(0) !== codes.caret) {
+      return nok(code);
+    }
+    effects.enter("gfmFootnoteCallLabelMarker");
+    effects.consume(code);
+    effects.exit("gfmFootnoteCallLabelMarker");
+    return ok(code);
+  }
+}
+
+// src/parser/ast/types.ts
+function extractMicromarkExtensions(plugins) {
+  const extensions = [];
+  const mdastExtensions = [];
+  for (const plugin of plugins) {
+    if ((plugin.type === "micromark" || plugin.type === "both") && plugin.micromark) {
+      extensions.push(...plugin.micromark.extensions);
+      mdastExtensions.push(...plugin.micromark.mdastExtensions);
+    }
+  }
+  return { extensions, mdastExtensions };
+}
+
+// src/parser/ast/MicromarkAstBuilder.ts
+var INLINE_CONTAINER_TYPES = [
+  "paragraph",
+  "heading",
+  "tableCell",
+  "delete",
+  "emphasis",
+  "strong",
+  "link",
+  "linkReference"
+];
+function isInlineContainer(node) {
+  return INLINE_CONTAINER_TYPES.includes(node.type);
+}
+var MicromarkAstBuilder = class {
+  options;
+  containerConfig;
+  htmlTreeConfig;
+  /** 缓存的扩展实例，避免每次 parse 都重新创建 */
+  cachedExtensions = [];
+  cachedMdastExtensions = [];
+  constructor(options = {}) {
+    this.options = options;
+    this.containerConfig = this.computeContainerConfig(options);
+    this.htmlTreeConfig = this.computeHtmlTreeConfig(options);
+    this.initExtensions();
+  }
+  /**
+   * 初始化并缓存扩展实例
+   */
+  initExtensions() {
+    if (this.options.gfm) {
+      this.cachedExtensions.push(gfm());
+      this.cachedMdastExtensions.push(...gfmFromMarkdown(), gfmFootnoteFromMarkdown());
+    }
+    if (this.options.math) {
+      const mathOptions = typeof this.options.math === "object" ? this.options.math : {};
+      this.cachedExtensions.push(math({
+        singleDollarTextMath: true,
+        tex: mathOptions.tex ?? false
+      }));
+      this.cachedMdastExtensions.push(mathFromMarkdown());
+    }
+    if (this.containerConfig !== void 0) {
+      this.cachedExtensions.push(directive());
+      this.cachedMdastExtensions.push(directiveFromMarkdown());
+    }
+    if (this.options.plugins) {
+      const { extensions, mdastExtensions } = extractMicromarkExtensions(this.options.plugins);
+      this.cachedExtensions.push(...extensions);
+      this.cachedMdastExtensions.push(...mdastExtensions);
+    }
+    if (this.options.extensions) {
+      this.cachedExtensions.push(...this.options.extensions);
+    }
+    if (this.options.mdastExtensions) {
+      this.cachedMdastExtensions.push(...this.options.mdastExtensions);
+    }
+    if (this.options.gfm) {
+      this.cachedExtensions.push(gfmFootnoteIncremental());
+    }
+    this.cachedExtensions.push(micromarkReferenceExtension());
+  }
+  /**
+   * 计算容器配置
+   */
+  computeContainerConfig(options) {
+    const containers = options.containers;
+    if (!containers) return void 0;
+    return containers === true ? {} : containers;
+  }
+  /**
+   * 计算 HTML 树配置
+   */
+  computeHtmlTreeConfig(options) {
+    const htmlTree = options.htmlTree;
+    if (!htmlTree) return void 0;
+    return htmlTree === true ? {} : htmlTree;
+  }
+  /**
+   * 解析文本为 AST
+   *
+   * @param text Markdown 文本
+   * @returns AST
+   */
+  parse(text) {
+    const ast = fromMarkdown(text, {
+      extensions: this.cachedExtensions,
+      mdastExtensions: this.cachedMdastExtensions
+    });
+    if (this.htmlTreeConfig) {
+      return transformHtmlNodes(ast, this.htmlTreeConfig);
+    } else {
+      return this.convertHtmlToText(ast);
+    }
+  }
+  /**
+   * 将 HTML 节点转换为纯文本（当未启用 HTML 树转换时）
+   *
+   * @param ast AST
+   * @returns 转换后的 AST
+   */
+  convertHtmlToText(ast) {
+    return {
+      ...ast,
+      children: this.processBlockChildren(ast.children)
+    };
+  }
+  /**
+   * 处理块级节点
+   */
+  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
+        };
+      }
+      return node;
+    });
+  }
+  /**
+   * 处理内联节点
+   */
+  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)
+        };
+      }
+      return n;
+    });
+  }
+  /**
+   * 将块级 HTML 节点转换为段落
+   */
+  convertBlockHtmlToParagraph(htmlNode) {
+    const textNode = {
+      type: "text",
+      value: htmlNode.value
+    };
+    const paragraphNode = {
+      type: "paragraph",
+      children: [textNode],
+      position: htmlNode.position
+    };
+    return paragraphNode;
+  }
+  /**
+   * 将内联 HTML 节点转换为纯文本节点
+   */
+  convertInlineHtmlToText(htmlNode) {
+    return {
+      type: "text",
+      value: htmlNode.value,
+      position: htmlNode.position
+    };
+  }
+  /**
+   * 将 AST 节点转换为 ParsedBlock
+   *
+   * @param nodes AST 节点列表
+   * @param startOffset 起始偏移量
+   * @param rawText 原始文本
+   * @param status 块状态
+   * @param generateBlockId 生成块 ID 的函数
+   * @returns 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 ?? 1;
+      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;
+  }
+  /**
+   * 更新配置选项
+   *
+   * 注意：由于 micromark 的扩展是在 constructor 中缓存的，
+   * 更新配置需要重新初始化扩展。
+   *
+   * @param options 部分配置选项
+   */
+  updateOptions(options) {
+    Object.assign(this.options, options);
+    if ("containers" in options) {
+      this.containerConfig = this.computeContainerConfig(this.options);
+    }
+    if ("htmlTree" in options) {
+      this.htmlTreeConfig = this.computeHtmlTreeConfig(this.options);
+    }
+    this.cachedExtensions.length = 0;
+    this.cachedMdastExtensions.length = 0;
+    this.initExtensions();
+  }
+};
+
+// src/engines/micromark/index.ts
+function createMicromarkBuilder(options = {}) {
+  return new MicromarkAstBuilder(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 { MicromarkAstBuilder, createMicromarkBuilder };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map