@incremark/core 0.1.2 → 0.2.0

package/dist/index.js

@@ -1,9 +1,1229 @@
 import { fromMarkdown } from 'mdast-util-from-markdown';
 import { gfmFromMarkdown } from 'mdast-util-gfm';
 import { gfm } from 'micromark-extension-gfm';
+import { codes, constants, types } from 'micromark-util-symbol';
+import { markdownLineEndingOrSpace, markdownSpace, markdownLineEnding } 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';
 
 // src/parser/IncremarkParser.ts
 
+// ../../node_modules/devlop/lib/default.js
+function ok() {
+}
+
+// ../../node_modules/micromark-util-normalize-identifier/index.js
+function normalizeIdentifier(value) {
+  return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
+}
+function enterFootnoteCallString() {
+  this.buffer();
+}
+function enterFootnoteCall(token) {
+  this.enter({ type: "footnoteReference", identifier: "", label: "" }, token);
+}
+function enterFootnoteDefinitionLabelString() {
+  this.buffer();
+}
+function enterFootnoteDefinition(token) {
+  this.enter(
+    { type: "footnoteDefinition", identifier: "", label: "", children: [] },
+    token
+  );
+}
+function exitFootnoteCallString(token) {
+  const label = this.resume();
+  const node = this.stack[this.stack.length - 1];
+  ok(node.type === "footnoteReference");
+  node.identifier = normalizeIdentifier(
+    this.sliceSerialize(token)
+  ).toLowerCase();
+  node.label = label;
+}
+function exitFootnoteCall(token) {
+  this.exit(token);
+}
+function exitFootnoteDefinitionLabelString(token) {
+  const label = this.resume();
+  const node = this.stack[this.stack.length - 1];
+  ok(node.type === "footnoteDefinition");
+  node.identifier = normalizeIdentifier(
+    this.sliceSerialize(token)
+  ).toLowerCase();
+  node.label = label;
+}
+function exitFootnoteDefinition(token) {
+  this.exit(token);
+}
+function gfmFootnoteFromMarkdown() {
+  return {
+    enter: {
+      gfmFootnoteCallString: enterFootnoteCallString,
+      gfmFootnoteCall: enterFootnoteCall,
+      gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
+      gfmFootnoteDefinition: enterFootnoteDefinition
+    },
+    exit: {
+      gfmFootnoteCallString: exitFootnoteCallString,
+      gfmFootnoteCall: exitFootnoteCall,
+      gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
+      gfmFootnoteDefinition: exitFootnoteDefinition
+    }
+  };
+}
+
+// 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 processHtmlNodesInArray(nodes, options) {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[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 < nodes.length && depth > 0) {
+          const nextNode = nodes[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 createHtmlTreeTransformer(options = {}) {
+  return function transformer(tree) {
+    return transformHtmlNodes(tree, options);
+  };
+}
+var htmlTreeExtension = {
+  enter: {},
+  exit: {}
+};
+function isHtmlElementNode(node) {
+  return node.type === "htmlElement";
+}
+function walkHtmlElements(node, callback, parent = null) {
+  if (isHtmlElementNode(node)) {
+    callback(node, parent);
+  }
+  if (hasChildren(node) || node.type === "root") {
+    const children = node.children;
+    for (const child of children) {
+      walkHtmlElements(child, callback, node);
+    }
+  }
+}
+function findHtmlElementsByTag(root, tagName) {
+  const result = [];
+  walkHtmlElements(root, (node) => {
+    if (node.tagName === tagName.toLowerCase()) {
+      result.push(node);
+    }
+  });
+  return result;
+}
+function htmlElementToString(node) {
+  const { tagName, attrs, children } = node;
+  const attrsStr = Object.entries(attrs).map(([name, value]) => {
+    if (value === "") return name;
+    return `${name}="${escapeHtml(value)}"`;
+  }).join(" ");
+  const openTag = attrsStr ? `<${tagName} ${attrsStr}>` : `<${tagName}>`;
+  if (children.length === 0 && isSelfClosingTag(tagName)) {
+    return attrsStr ? `<${tagName} ${attrsStr} />` : `<${tagName} />`;
+  }
+  const childrenStr = children.map((child) => {
+    if (child.type === "text") {
+      return child.value;
+    }
+    if (isHtmlElementNode(child)) {
+      return htmlElementToString(child);
+    }
+    return "";
+  }).join("");
+  return `${openTag}${childrenStr}</${tagName}>`;
+}
+function isSelfClosingTag(tagName) {
+  return ["br", "hr", "img", "input", "meta", "link", "area", "base", "col", "embed", "source", "track", "wbr"].includes(tagName.toLowerCase());
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+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, ok2, 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 ok2(code);
+  }
+  function labelEndNok(code) {
+    labelStart._balanced = true;
+    return nok(code);
+  }
+}
+function tokenizeResource(effects, ok2, 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 ok2;
+    }
+    return nok(code);
+  }
+}
+function tokenizeReferenceFull(effects, ok2, 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 ok2(code);
+  }
+  function referenceFullMissing(code) {
+    return nok(code);
+  }
+}
+function tokenizeReferenceCollapsed(effects, ok2, 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 ok2;
+    }
+    return nok(code);
+  }
+}
+function factorySpace(effects, ok2, type, max) {
+  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+  let size = 0;
+  return start;
+  function start(code) {
+    if (markdownSpace(code)) {
+      effects.enter(type);
+      return prefix(code);
+    }
+    return ok2(code);
+  }
+  function prefix(code) {
+    if (markdownSpace(code) && size++ < limit) {
+      effects.consume(code);
+      return prefix;
+    }
+    effects.exit(type);
+    return ok2(code);
+  }
+}
+var blankLine = {
+  partial: true,
+  tokenize: tokenizeBlankLine
+};
+function tokenizeBlankLine(effects, ok2, nok) {
+  return start;
+  function start(code) {
+    return markdownSpace(code) ? factorySpace(effects, after, "linePrefix")(code) : after(code);
+  }
+  function after(code) {
+    return code === null || markdownLineEnding(code) ? ok2(code) : nok(code);
+  }
+}
+var indent = {
+  tokenize: tokenizeIndent,
+  partial: true
+};
+function gfmFootnote() {
+  return {
+    document: {
+      [91]: {
+        name: "gfmFootnoteDefinition",
+        tokenize: tokenizeDefinitionStart,
+        continuation: {
+          tokenize: tokenizeDefinitionContinuation
+        },
+        exit: gfmFootnoteDefinitionEnd
+      }
+    },
+    text: {
+      [91]: {
+        name: "gfmFootnoteCall",
+        tokenize: tokenizeGfmFootnoteCall
+      },
+      [93]: {
+        name: "gfmPotentialFootnoteCall",
+        add: "after",
+        tokenize: tokenizePotentialGfmFootnoteCall,
+        resolveTo: resolveToPotentialGfmFootnoteCall
+      }
+    }
+  };
+}
+function tokenizePotentialGfmFootnoteCall(effects, ok2, nok) {
+  const self = this;
+  let index = self.events.length;
+  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+  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 (!labelStart || !labelStart._balanced) {
+      return nok(code);
+    }
+    const id = normalizeIdentifier(self.sliceSerialize({
+      start: labelStart.end,
+      end: self.now()
+    }));
+    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {
+      return nok(code);
+    }
+    effects.enter("gfmFootnoteCallLabelMarker");
+    effects.consume(code);
+    effects.exit("gfmFootnoteCallLabelMarker");
+    return ok2(code);
+  }
+}
+function resolveToPotentialGfmFootnoteCall(events, context) {
+  let index = events.length;
+  while (index--) {
+    if (events[index][1].type === "labelImage" && events[index][0] === "enter") {
+      events[index][1];
+      break;
+    }
+  }
+  events[index + 1][1].type = "data";
+  events[index + 3][1].type = "gfmFootnoteCallLabelMarker";
+  const call = {
+    type: "gfmFootnoteCall",
+    start: Object.assign({}, events[index + 3][1].start),
+    end: Object.assign({}, events[events.length - 1][1].end)
+  };
+  const marker = {
+    type: "gfmFootnoteCallMarker",
+    start: Object.assign({}, events[index + 3][1].end),
+    end: Object.assign({}, events[index + 3][1].end)
+  };
+  marker.end.column++;
+  marker.end.offset++;
+  marker.end._bufferIndex++;
+  const string = {
+    type: "gfmFootnoteCallString",
+    start: Object.assign({}, marker.end),
+    end: Object.assign({}, events[events.length - 1][1].start)
+  };
+  const chunk = {
+    type: "chunkString",
+    contentType: "string",
+    start: Object.assign({}, string.start),
+    end: Object.assign({}, string.end)
+  };
+  const replacement = [
+    // Take the `labelImageMarker` (now `data`, the `!`)
+    events[index + 1],
+    events[index + 2],
+    ["enter", call, context],
+    // The `[`
+    events[index + 3],
+    events[index + 4],
+    // The `^`.
+    ["enter", marker, context],
+    ["exit", marker, context],
+    // Everything in between.
+    ["enter", string, context],
+    ["enter", chunk, context],
+    ["exit", chunk, context],
+    ["exit", string, context],
+    // The ending (`]`, properly parsed and labelled).
+    events[events.length - 2],
+    events[events.length - 1],
+    ["exit", call, context]
+  ];
+  events.splice(index, events.length - index + 1, ...replacement);
+  return events;
+}
+function tokenizeGfmFootnoteCall(effects, ok2, nok) {
+  const self = this;
+  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+  let size = 0;
+  let data;
+  return start;
+  function start(code) {
+    effects.enter("gfmFootnoteCall");
+    effects.enter("gfmFootnoteCallLabelMarker");
+    effects.consume(code);
+    effects.exit("gfmFootnoteCallLabelMarker");
+    return callStart;
+  }
+  function callStart(code) {
+    if (code !== 94) return nok(code);
+    effects.enter("gfmFootnoteCallMarker");
+    effects.consume(code);
+    effects.exit("gfmFootnoteCallMarker");
+    effects.enter("gfmFootnoteCallString");
+    effects.enter("chunkString").contentType = "string";
+    return callData;
+  }
+  function callData(code) {
+    if (
+      // Too long.
+      size > 999 || // Closing brace with nothing.
+      code === 93 && !data || // Space or tab is not supported by GFM for some reason.
+      // `\n` and `[` not being supported makes sense.
+      code === null || code === 91 || markdownLineEndingOrSpace(code)
+    ) {
+      return nok(code);
+    }
+    if (code === 93) {
+      effects.exit("chunkString");
+      const token = effects.exit("gfmFootnoteCallString");
+      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {
+        return nok(code);
+      }
+      effects.enter("gfmFootnoteCallLabelMarker");
+      effects.consume(code);
+      effects.exit("gfmFootnoteCallLabelMarker");
+      effects.exit("gfmFootnoteCall");
+      return ok2;
+    }
+    if (!markdownLineEndingOrSpace(code)) {
+      data = true;
+    }
+    size++;
+    effects.consume(code);
+    return code === 92 ? callEscape : callData;
+  }
+  function callEscape(code) {
+    if (code === 91 || code === 92 || code === 93) {
+      effects.consume(code);
+      size++;
+      return callData;
+    }
+    return callData(code);
+  }
+}
+function tokenizeDefinitionStart(effects, ok2, nok) {
+  const self = this;
+  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+  let identifier;
+  let size = 0;
+  let data;
+  return start;
+  function start(code) {
+    effects.enter("gfmFootnoteDefinition")._container = true;
+    effects.enter("gfmFootnoteDefinitionLabel");
+    effects.enter("gfmFootnoteDefinitionLabelMarker");
+    effects.consume(code);
+    effects.exit("gfmFootnoteDefinitionLabelMarker");
+    return labelAtMarker;
+  }
+  function labelAtMarker(code) {
+    if (code === 94) {
+      effects.enter("gfmFootnoteDefinitionMarker");
+      effects.consume(code);
+      effects.exit("gfmFootnoteDefinitionMarker");
+      effects.enter("gfmFootnoteDefinitionLabelString");
+      effects.enter("chunkString").contentType = "string";
+      return labelInside;
+    }
+    return nok(code);
+  }
+  function labelInside(code) {
+    if (
+      // Too long.
+      size > 999 || // Closing brace with nothing.
+      code === 93 && !data || // Space or tab is not supported by GFM for some reason.
+      // `\n` and `[` not being supported makes sense.
+      code === null || code === 91 || markdownLineEndingOrSpace(code)
+    ) {
+      return nok(code);
+    }
+    if (code === 93) {
+      effects.exit("chunkString");
+      const token = effects.exit("gfmFootnoteDefinitionLabelString");
+      identifier = normalizeIdentifier(self.sliceSerialize(token));
+      effects.enter("gfmFootnoteDefinitionLabelMarker");
+      effects.consume(code);
+      effects.exit("gfmFootnoteDefinitionLabelMarker");
+      effects.exit("gfmFootnoteDefinitionLabel");
+      return labelAfter;
+    }
+    if (!markdownLineEndingOrSpace(code)) {
+      data = true;
+    }
+    size++;
+    effects.consume(code);
+    return code === 92 ? labelEscape : labelInside;
+  }
+  function labelEscape(code) {
+    if (code === 91 || code === 92 || code === 93) {
+      effects.consume(code);
+      size++;
+      return labelInside;
+    }
+    return labelInside(code);
+  }
+  function labelAfter(code) {
+    if (code === 58) {
+      effects.enter("definitionMarker");
+      effects.consume(code);
+      effects.exit("definitionMarker");
+      if (!defined.includes(identifier)) {
+        defined.push(identifier);
+      }
+      return factorySpace(effects, whitespaceAfter, "gfmFootnoteDefinitionWhitespace");
+    }
+    return nok(code);
+  }
+  function whitespaceAfter(code) {
+    return ok2(code);
+  }
+}
+function tokenizeDefinitionContinuation(effects, ok2, nok) {
+  return effects.check(blankLine, ok2, effects.attempt(indent, ok2, nok));
+}
+function gfmFootnoteDefinitionEnd(effects) {
+  effects.exit("gfmFootnoteDefinition");
+}
+function tokenizeIndent(effects, ok2, nok) {
+  const self = this;
+  return factorySpace(effects, afterPrefix, "gfmFootnoteDefinitionIndent", 4 + 1);
+  function afterPrefix(code) {
+    const tail = self.events[self.events.length - 1];
+    return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok2(code) : 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, ok2, 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 ok2;
+    }
+    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, ok2, 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 ok2(code);
+  }
+}
+
 // src/detector/index.ts
 var RE_FENCE_START = /^(\s*)((`{3,})|(~{3,}))/;
 var RE_EMPTY_LINE = /^\s*$/;
@@ -16,6 +1236,8 @@ var RE_HTML_BLOCK_1 = /^\s{0,3}<(script|pre|style|textarea|!--|!DOCTYPE|\?|!\[CD
 var RE_HTML_BLOCK_2 = /^\s{0,3}<\/?[a-zA-Z][a-zA-Z0-9-]*(\s|>|$)/;
 var RE_TABLE_DELIMITER = /^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?$/;
 var RE_ESCAPE_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+var RE_FOOTNOTE_DEFINITION = /^\[\^[^\]]+\]:\s/;
+var RE_FOOTNOTE_CONTINUATION = /^(?:    |\t)/;
 var fenceEndPatternCache = /* @__PURE__ */ new Map();
 var containerPatternCache = /* @__PURE__ */ new Map();
 function detectFenceStart(line) {
@@ -68,6 +1290,12 @@ function isHtmlBlock(line) {
 function isTableDelimiter(line) {
   return RE_TABLE_DELIMITER.test(line.trim());
 }
+function isFootnoteDefinitionStart(line) {
+  return RE_FOOTNOTE_DEFINITION.test(line);
+}
+function isFootnoteContinuation(line) {
+  return RE_FOOTNOTE_CONTINUATION.test(line);
+}
 function detectContainer(line, config) {
   const marker = config?.marker || ":";
   const minLength = config?.minMarkerLength || 3;
@@ -179,6 +1407,34 @@ function updateContext(line, context, containerConfig) {
   return newContext;
 }
 
+// src/utils/index.ts
+var idCounter = 0;
+function generateId(prefix = "block") {
+  return `${prefix}-${++idCounter}`;
+}
+function resetIdCounter() {
+  idCounter = 0;
+}
+function calculateLineOffset(lines, lineIndex) {
+  let offset = 0;
+  for (let i = 0; i < lineIndex && i < lines.length; i++) {
+    offset += lines[i].length + 1;
+  }
+  return offset;
+}
+function splitLines(text) {
+  return text.split("\n");
+}
+function joinLines(lines, start, end) {
+  return lines.slice(start, end + 1).join("\n");
+}
+function isDefinitionNode(node) {
+  return node.type === "definition";
+}
+function isFootnoteDefinitionNode(node) {
+  return node.type === "footnoteDefinition";
+}
+
 // src/parser/IncremarkParser.ts
 var IncremarkParser = class {
   buffer = "";
@@ -192,8 +1448,16 @@ var IncremarkParser = class {
   options;
   /** 缓存的容器配置，避免重复计算 */
   containerConfig;
+  /** 缓存的 HTML 树配置，避免重复计算 */
+  htmlTreeConfig;
   /** 上次 append 返回的 pending blocks，用于 getAst 复用 */
   lastPendingBlocks = [];
+  /** Definition 映射表（用于引用式图片和链接） */
+  definitionMap = {};
+  /** Footnote Definition 映射表 */
+  footnoteDefinitionMap = {};
+  /** Footnote Reference 出现顺序（按引用在文档中的顺序） */
+  footnoteReferenceOrder = [];
   constructor(options = {}) {
     this.options = {
       gfm: true,
@@ -201,6 +1465,7 @@ var IncremarkParser = class {
     };
     this.context = createInitialContext();
     this.containerConfig = this.computeContainerConfig();
+    this.htmlTreeConfig = this.computeHtmlTreeConfig();
   }
   generateBlockId() {
     return `block-${++this.blockIdCounter}`;
@@ -210,12 +1475,82 @@ var IncremarkParser = class {
     if (!containers) return void 0;
     return containers === true ? {} : containers;
   }
+  computeHtmlTreeConfig() {
+    const htmlTree = this.options.htmlTree;
+    if (!htmlTree) return void 0;
+    return htmlTree === true ? {} : htmlTree;
+  }
+  /**
+   * 将 HTML 节点转换为纯文本
+   * 递归处理 AST 中所有 html 类型的节点
+   * - 块级 HTML 节点 → 转换为 paragraph 包含 text
+   * - 内联 HTML 节点（在段落内部）→ 转换为 text 节点
+   */
+  convertHtmlToText(ast) {
+    const processInlineChildren = (children) => {
+      return children.map((node) => {
+        const n = node;
+        if (n.type === "html") {
+          const htmlNode = n;
+          const textNode = {
+            type: "text",
+            value: htmlNode.value,
+            position: htmlNode.position
+          };
+          return textNode;
+        }
+        if ("children" in n && Array.isArray(n.children)) {
+          const parent = n;
+          return {
+            ...parent,
+            children: processInlineChildren(parent.children)
+          };
+        }
+        return n;
+      });
+    };
+    const processBlockChildren = (children) => {
+      return children.map((node) => {
+        if (node.type === "html") {
+          const htmlNode = node;
+          const textNode = {
+            type: "text",
+            value: htmlNode.value
+          };
+          const paragraphNode = {
+            type: "paragraph",
+            children: [textNode],
+            position: htmlNode.position
+          };
+          return paragraphNode;
+        }
+        if ("children" in node && Array.isArray(node.children)) {
+          const parent = node;
+          if (node.type === "paragraph" || node.type === "heading" || node.type === "tableCell" || node.type === "delete" || node.type === "emphasis" || node.type === "strong" || node.type === "link" || node.type === "linkReference") {
+            return {
+              ...parent,
+              children: processInlineChildren(parent.children)
+            };
+          }
+          return {
+            ...parent,
+            children: processBlockChildren(parent.children)
+          };
+        }
+        return node;
+      });
+    };
+    return {
+      ...ast,
+      children: processBlockChildren(ast.children)
+    };
+  }
   parse(text) {
     const extensions = [];
     const mdastExtensions = [];
     if (this.options.gfm) {
       extensions.push(gfm());
-      mdastExtensions.push(...gfmFromMarkdown());
+      mdastExtensions.push(...gfmFromMarkdown(), gfmFootnoteFromMarkdown());
     }
     if (this.options.extensions) {
       extensions.push(...this.options.extensions);
@@ -223,7 +1558,79 @@ var IncremarkParser = class {
     if (this.options.mdastExtensions) {
       mdastExtensions.push(...this.options.mdastExtensions);
     }
-    return fromMarkdown(text, { extensions, mdastExtensions });
+    if (this.options.gfm) {
+      extensions.push(gfmFootnoteIncremental());
+    }
+    extensions.push(micromarkReferenceExtension());
+    let ast = fromMarkdown(text, { extensions, mdastExtensions });
+    if (this.htmlTreeConfig) {
+      ast = transformHtmlNodes(ast, this.htmlTreeConfig);
+    } else {
+      ast = this.convertHtmlToText(ast);
+    }
+    return ast;
+  }
+  updateDefinationsFromComplatedBlocks(blocks) {
+    for (const block of blocks) {
+      this.definitionMap = {
+        ...this.definitionMap,
+        ...this.findDefinition(block)
+      };
+      this.footnoteDefinitionMap = {
+        ...this.footnoteDefinitionMap,
+        ...this.findFootnoteDefinition(block)
+      };
+    }
+  }
+  findDefinition(block) {
+    const definitions = [];
+    function findDefination(node) {
+      if (isDefinitionNode(node)) {
+        definitions.push(node);
+      }
+      if ("children" in node && Array.isArray(node.children)) {
+        for (const child of node.children) {
+          findDefination(child);
+        }
+      }
+    }
+    findDefination(block.node);
+    return definitions.reduce((acc, node) => {
+      acc[node.identifier] = node;
+      return acc;
+    }, {});
+  }
+  findFootnoteDefinition(block) {
+    const footnoteDefinitions = [];
+    function findFootnoteDefinition(node) {
+      if (isFootnoteDefinitionNode(node)) {
+        footnoteDefinitions.push(node);
+      }
+    }
+    findFootnoteDefinition(block.node);
+    return footnoteDefinitions.reduce((acc, node) => {
+      acc[node.identifier] = node;
+      return acc;
+    }, {});
+  }
+  /**
+   * 收集 AST 中的脚注引用（按出现顺序）
+   * 用于确定脚注的显示顺序
+   */
+  collectFootnoteReferences(nodes) {
+    const visitNode = (node) => {
+      if (!node) return;
+      if (node.type === "footnoteReference") {
+        const identifier = node.identifier;
+        if (!this.footnoteReferenceOrder.includes(identifier)) {
+          this.footnoteReferenceOrder.push(identifier);
+        }
+      }
+      if (node.children && Array.isArray(node.children)) {
+        node.children.forEach(visitNode);
+      }
+    };
+    nodes.forEach(visitNode);
   }
   /**
    * 增量更新 lines 和 lineOffsets
@@ -310,7 +1717,30 @@ var IncremarkParser = class {
     if (lineIndex >= this.lines.length - 1) {
       return -1;
     }
+    if (isFootnoteDefinitionStart(prevLine)) {
+      if (isEmptyLine(line) || isFootnoteContinuation(line)) {
+        return -1;
+      }
+      if (isFootnoteDefinitionStart(line)) {
+        return lineIndex - 1;
+      }
+    }
+    if (!isEmptyLine(prevLine) && isFootnoteContinuation(prevLine)) {
+      const footnoteStartLine = this.findFootnoteStart(lineIndex - 1);
+      if (footnoteStartLine >= 0) {
+        if (isEmptyLine(line) || isFootnoteContinuation(line)) {
+          return -1;
+        }
+        if (isFootnoteDefinitionStart(line)) {
+          return lineIndex - 1;
+        }
+        return lineIndex - 1;
+      }
+    }
     if (!isEmptyLine(prevLine)) {
+      if (isFootnoteDefinitionStart(line) && !isFootnoteDefinitionStart(prevLine)) {
+        return lineIndex - 1;
+      }
       if (isHeading(line)) {
         return lineIndex - 1;
       }
@@ -338,6 +1768,37 @@ var IncremarkParser = class {
     }
     return -1;
   }
+  /**
+   * 从指定行向上查找脚注定义的起始行
+   * 
+   * @param fromLine 开始查找的行索引
+   * @returns 脚注起始行索引，如果不属于脚注返回 -1
+   * 
+   * @example
+   * // 假设 lines 为:
+   * // 0: "[^1]: 第一行"
+   * // 1: "    第二行"
+   * // 2: "    第三行"
+   * findFootnoteStart(2) // 返回 0
+   * findFootnoteStart(1) // 返回 0
+   */
+  findFootnoteStart(fromLine) {
+    const maxLookback = 20;
+    const startLine = Math.max(0, fromLine - maxLookback);
+    for (let i = fromLine; i >= startLine; i--) {
+      const line = this.lines[i];
+      if (isFootnoteDefinitionStart(line)) {
+        return i;
+      }
+      if (isEmptyLine(line)) {
+        continue;
+      }
+      if (!isFootnoteContinuation(line)) {
+        return -1;
+      }
+    }
+    return -1;
+  }
   nodesToBlocks(nodes, startOffset, rawText, status) {
     const blocks = [];
     let currentOffset = startOffset;
@@ -368,7 +1829,10 @@ var IncremarkParser = class {
       completed: [],
       updated: [],
       pending: [],
-      ast: { type: "root", children: [] }
+      ast: { type: "root", children: [] },
+      definitions: {},
+      footnoteDefinitions: {},
+      footnoteReferenceOrder: []
     };
     if (stableBoundary >= this.pendingStartLine && stableBoundary >= 0) {
       const stableText = this.lines.slice(this.pendingStartLine, stableBoundary + 1).join("\n");
@@ -377,6 +1841,7 @@ var IncremarkParser = class {
       const newBlocks = this.nodesToBlocks(ast.children, stableOffset, stableText, "completed");
       this.completedBlocks.push(...newBlocks);
       update.completed = newBlocks;
+      this.updateDefinationsFromComplatedBlocks(newBlocks);
       this.context = contextAtLine;
       this.pendingStartLine = stableBoundary + 1;
     }
@@ -393,6 +1858,10 @@ var IncremarkParser = class {
       type: "root",
       children: [...this.completedBlocks.map((b) => b.node), ...update.pending.map((b) => b.node)]
     };
+    this.collectFootnoteReferences(update.ast.children);
+    update.definitions = this.getDefinitionMap();
+    update.footnoteDefinitions = this.getFootnoteDefinitionMap();
+    update.footnoteReferenceOrder = this.getFootnoteReferenceOrder();
     this.emitChange(update.pending);
     return update;
   }
@@ -401,7 +1870,7 @@ var IncremarkParser = class {
    */
   emitChange(pendingBlocks = []) {
     if (this.options.onChange) {
-      this.options.onChange({
+      const state = {
         completedBlocks: this.completedBlocks,
         pendingBlocks,
         markdown: this.buffer,
@@ -411,8 +1880,11 @@ var IncremarkParser = class {
             ...this.completedBlocks.map((b) => b.node),
             ...pendingBlocks.map((b) => b.node)
           ]
-        }
-      });
+        },
+        definitions: { ...this.definitionMap },
+        footnoteDefinitions: { ...this.footnoteDefinitionMap }
+      };
+      this.options.onChange(state);
     }
   }
   /**
@@ -424,7 +1896,10 @@ var IncremarkParser = class {
       completed: [],
       updated: [],
       pending: [],
-      ast: { type: "root", children: [] }
+      ast: { type: "root", children: [] },
+      definitions: {},
+      footnoteDefinitions: {},
+      footnoteReferenceOrder: []
     };
     if (this.pendingStartLine < this.lines.length) {
       const remainingText = this.lines.slice(this.pendingStartLine).join("\n");
@@ -439,6 +1914,7 @@ var IncremarkParser = class {
         );
         this.completedBlocks.push(...finalBlocks);
         update.completed = finalBlocks;
+        this.updateDefinationsFromComplatedBlocks(finalBlocks);
       }
     }
     this.lastPendingBlocks = [];
@@ -447,6 +1923,10 @@ var IncremarkParser = class {
       type: "root",
       children: this.completedBlocks.map((b) => b.node)
     };
+    this.collectFootnoteReferences(update.ast.children);
+    update.definitions = this.getDefinitionMap();
+    update.footnoteDefinitions = this.getFootnoteDefinitionMap();
+    update.footnoteReferenceOrder = this.getFootnoteReferenceOrder();
     this.emitChange([]);
     return update;
   }
@@ -462,12 +1942,14 @@ var IncremarkParser = class {
    * 复用上次 append 的 pending 结果，避免重复解析
    */
   getAst() {
+    const children = [
+      ...this.completedBlocks.map((b) => b.node),
+      ...this.lastPendingBlocks.map((b) => b.node)
+    ];
+    this.collectFootnoteReferences(children);
     return {
       type: "root",
-      children: [
-        ...this.completedBlocks.map((b) => b.node),
-        ...this.lastPendingBlocks.map((b) => b.node)
-      ]
+      children
     };
   }
   /**
@@ -482,11 +1964,33 @@ var IncremarkParser = class {
   getBuffer() {
     return this.buffer;
   }
+  /**
+   * 获取 Definition 映射表（用于引用式图片和链接）
+   */
+  getDefinitionMap() {
+    return { ...this.definitionMap };
+  }
+  /**
+   * 获取 Footnote Definition 映射表
+   */
+  getFootnoteDefinitionMap() {
+    return { ...this.footnoteDefinitionMap };
+  }
+  /**
+   * 获取脚注引用的出现顺序
+   */
+  getFootnoteReferenceOrder() {
+    return [...this.footnoteReferenceOrder];
+  }
   /**
    * 设置状态变化回调（用于 DevTools 等）
    */
   setOnChange(callback) {
-    this.options.onChange = callback;
+    const originalOnChange = this.options.onChange;
+    this.options.onChange = (state) => {
+      originalOnChange?.(state);
+      callback?.(state);
+    };
   }
   /**
    * 重置解析器状态
@@ -500,6 +2004,9 @@ var IncremarkParser = class {
     this.blockIdCounter = 0;
     this.context = createInitialContext();
     this.lastPendingBlocks = [];
+    this.definitionMap = {};
+    this.footnoteDefinitionMap = {};
+    this.footnoteReferenceOrder = [];
     this.emitChange([]);
   }
   /**
@@ -517,28 +2024,6 @@ function createIncremarkParser(options) {
   return new IncremarkParser(options);
 }
 
-// src/utils/index.ts
-var idCounter = 0;
-function generateId(prefix = "block") {
-  return `${prefix}-${++idCounter}`;
-}
-function resetIdCounter() {
-  idCounter = 0;
-}
-function calculateLineOffset(lines, lineIndex) {
-  let offset = 0;
-  for (let i = 0; i < lineIndex && i < lines.length; i++) {
-    offset += lines[i].length + 1;
-  }
-  return offset;
-}
-function splitLines(text) {
-  return text.split("\n");
-}
-function joinLines(lines, start, end) {
-  return lines.slice(start, end + 1).join("\n");
-}
-
 // src/transformer/utils.ts
 function countChars(node) {
   return countCharsInNode(node);
@@ -1256,7 +2741,51 @@ function createPlugin(name, matcher, options = {}) {
     ...options
   };
 }
+/**
+ * @file Micromark 扩展：支持增量解析的 Reference 语法
+ * 
+ * @description
+ * 在增量解析场景中，引用式图片/链接（如 `![Alt][id]`）可能在定义（`[id]: url`）之前出现。
+ * 标准 micromark 会检查 parser.defined，如果 id 未定义就解析为文本。
+ * 
+ * 本扩展通过覆盖 labelEnd 构造，移除 parser.defined 检查，
+ * 使得 reference 语法总是被解析为 reference token，
+ * 由渲染层根据实际的 definitionMap 决定如何渲染。
+ * 
+ * @module micromark-reference-extension
+ * 
+ * @features
+ * - ✅ 支持所有 resource 语法（带 title 的图片/链接）
+ * - ✅ 支持所有 reference 语法（full, collapsed, shortcut）
+ * - ✅ 延迟验证：解析时不检查定义是否存在
+ * - ✅ 使用官方 factory 函数，保证与 CommonMark 标准一致
+ * 
+ * @dependencies
+ * - micromark-factory-destination: 解析 URL（支持尖括号、括号平衡）
+ * - micromark-factory-title: 解析 title（支持三种引号，支持多行）
+ * - micromark-factory-label: 解析 label（支持转义、长度限制）
+ * - micromark-factory-whitespace: 解析空白符（正确生成 lineEnding/linePrefix token）
+ * - micromark-util-character: 字符判断工具
+ * - micromark-util-symbol: 常量（codes, types, constants）
+ * - micromark-util-types: TypeScript 类型定义
+ * 
+ * @see {@link https://github.com/micromark/micromark} - micromark 官方文档
+ * @see {@link https://spec.commonmark.org/0.30/#images} - CommonMark 图片规范
+ * @see {@link https://spec.commonmark.org/0.30/#links} - CommonMark 链接规范
+ * 
+ * @example
+ * ```typescript
+ * import { micromarkReferenceExtension } from './micromark-reference-extension'
+ * import { fromMarkdown } from 'mdast-util-from-markdown'
+ * 
+ * const extensions = [micromarkReferenceExtension()]
+ * const ast = fromMarkdown(text, { extensions })
+ * ```
+ * 
+ * @author Incremark Team
+ * @license MIT
+ */
 
-export { BlockTransformer, IncremarkParser, allPlugins, calculateLineOffset, cloneNode, codeBlockPlugin, countChars, createBlockTransformer, createIncremarkParser, createInitialContext, createPlugin, defaultPlugins, detectContainer, detectContainerEnd, detectFenceEnd, detectFenceStart, generateId, imagePlugin, isBlockBoundary, isBlockquoteStart, isEmptyLine, isHeading, isHtmlBlock, isListItemStart, isTableDelimiter, isThematicBreak, joinLines, mathPlugin, mermaidPlugin, resetIdCounter, sliceAst, splitLines, thematicBreakPlugin, updateContext };
+export { BlockTransformer, DEFAULT_ATTR_BLACKLIST as HTML_ATTR_BLACKLIST, DEFAULT_PROTOCOL_BLACKLIST as HTML_PROTOCOL_BLACKLIST, DEFAULT_TAG_BLACKLIST as HTML_TAG_BLACKLIST, IncremarkParser, allPlugins, calculateLineOffset, cloneNode, codeBlockPlugin, countChars, createBlockTransformer, createHtmlTreeTransformer, createIncremarkParser, createInitialContext, createPlugin, defaultPlugins, detectContainer, detectContainerEnd, detectFenceEnd, detectFenceStart, detectHtmlContentType, findHtmlElementsByTag, generateId, htmlElementToString, htmlTreeExtension, imagePlugin, isBlockBoundary, isBlockquoteStart, isEmptyLine, isHeading, isHtmlBlock, isHtmlElementNode, isListItemStart, isTableDelimiter, isThematicBreak, joinLines, mathPlugin, mermaidPlugin, parseHtmlFragment, parseHtmlTag, resetIdCounter, sliceAst, splitLines, thematicBreakPlugin, transformHtmlNodes, updateContext, walkHtmlElements };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map