@f-o-t/markdown 1.0.0

package/dist/index.js

@@ -0,0 +1,3512 @@
+// src/utils.ts
+function detectEncoding(buffer) {
+  if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+    return { encoding: "utf-8", bomLength: 3 };
+  }
+  if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254) {
+    return { encoding: "utf-16le", bomLength: 2 };
+  }
+  if (buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255) {
+    return { encoding: "utf-16be", bomLength: 2 };
+  }
+  return { encoding: "utf-8", bomLength: 0 };
+}
+function decodeBuffer(buffer) {
+  const { encoding, bomLength } = detectEncoding(buffer);
+  const data = bomLength > 0 ? buffer.slice(bomLength) : buffer;
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(data);
+}
+function detectLineEnding(content) {
+  const crlfIndex = content.indexOf(`\r
+`);
+  const lfIndex = content.indexOf(`
+`);
+  if (crlfIndex !== -1 && (lfIndex === -1 || crlfIndex <= lfIndex)) {
+    return `\r
+`;
+  }
+  return `
+`;
+}
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n?/g, `
+`);
+}
+function normalizeEscapedNewlines(content) {
+  return content.replace(/\\\\n/g, `
+`).replace(/\\n/g, `
+`);
+}
+function splitLines(content) {
+  const normalized = normalizeLineEndings(content);
+  const rawLines = normalized.split(`
+`);
+  let offset = 0;
+  return rawLines.map((raw, index) => {
+    const indent = countIndent(raw);
+    const lineContent = raw.slice(indent);
+    const lineOffset = offset;
+    offset += raw.length + 1;
+    return {
+      raw,
+      content: lineContent,
+      indent,
+      lineNumber: index + 1,
+      isBlank: lineContent.length === 0,
+      offset: lineOffset
+    };
+  });
+}
+function countIndent(line) {
+  let indent = 0;
+  for (const char of line) {
+    if (char === " ") {
+      indent++;
+    } else if (char === "\t") {
+      indent = Math.ceil((indent + 1) / 4) * 4;
+    } else {
+      break;
+    }
+  }
+  return indent;
+}
+function removeIndent(line, amount) {
+  let removed = 0;
+  let i = 0;
+  while (i < line.length && removed < amount) {
+    const char = line[i];
+    if (char === " ") {
+      removed++;
+      i++;
+    } else if (char === "\t") {
+      const tabWidth = 4 - removed % 4;
+      if (removed + tabWidth <= amount) {
+        removed += tabWidth;
+        i++;
+      } else {
+        const spaces = amount - removed;
+        return " ".repeat(tabWidth - spaces) + line.slice(i + 1);
+      }
+    } else {
+      break;
+    }
+  }
+  return line.slice(i);
+}
+function isBlankLine(line) {
+  return line.trim().length === 0;
+}
+var ESCAPABLE = "\\!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~";
+function unescapeMarkdown(text) {
+  const parts = [];
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "\\" && i + 1 < text.length) {
+      const nextChar = text[i + 1];
+      if (nextChar && ESCAPABLE.includes(nextChar)) {
+        parts.push(nextChar);
+        i += 2;
+        continue;
+      }
+    }
+    parts.push(text[i]);
+    i++;
+  }
+  return parts.join("");
+}
+function normalizeMarkdownEmphasis(text) {
+  return text.replace(/\\(\*{1,2})/g, "$1");
+}
+var HTML_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  copy: "©",
+  reg: "®",
+  trade: "™",
+  mdash: "—",
+  ndash: "–",
+  hellip: "…",
+  lsquo: "‘",
+  rsquo: "’",
+  ldquo: "“",
+  rdquo: "”"
+};
+var HTML_ENTITY_REGEX = /&(?:#(\d+)|#[xX]([0-9a-fA-F]+)|([a-zA-Z]+));/g;
+function decodeHtmlEntities(text) {
+  return text.replace(HTML_ENTITY_REGEX, (match, decimal, hex, named) => {
+    if (decimal) {
+      const num = Number.parseInt(decimal, 10);
+      return num > 0 && num < 1114111 ? String.fromCodePoint(num) : match;
+    }
+    if (hex) {
+      const num = Number.parseInt(hex, 16);
+      return num > 0 && num < 1114111 ? String.fromCodePoint(num) : match;
+    }
+    if (named) {
+      return HTML_ENTITIES[named] ?? match;
+    }
+    return match;
+  });
+}
+function encodeHtmlEntities(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function encodeUrl(url) {
+  return url.replace(/%/g, "%25").replace(/ /g, "%20").replace(/\(/g, "%28").replace(/\)/g, "%29");
+}
+function normalizeLabel(label) {
+  return label.trim().toLowerCase().replace(/[\t\n\r ]+/g, " ");
+}
+function repeat(str, count) {
+  return str.repeat(Math.max(0, count));
+}
+var ATX_HEADING_REGEX = /^(#{1,6})(?:[ \t]+(.*))?$/;
+var SETEXT_HEADING_REGEX = /^(=+|-+)[ \t]*$/;
+var THEMATIC_BREAK_REGEX = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+var FENCED_CODE_OPEN_REGEX = /^(`{3,}|~{3,})[ \t]*([^`\n]*)?$/;
+var ORDERED_LIST_REGEX = /^(\d{1,9})([.)])[ \t]+/;
+var UNORDERED_LIST_REGEX = /^([-*+])[ \t]+/;
+var BLOCKQUOTE_REGEX = /^>[ \t]?/;
+var LINK_REFERENCE_REGEX = /^\[([^\]]+)\]:[ \t]*<?([^\s>]+)>?(?:[ \t]+(?:"([^"]*)"|'([^']*)'|\(([^)]*)\)))?[ \t]*$/;
+var AUTOLINK_REGEX = /^<([a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^\s<>]*)>$/;
+var EMAIL_AUTOLINK_REGEX = /^<([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>$/;
+var HTML_BLOCK_1_OPEN = /^<(?:script|pre|style|textarea)(?:\s|>|$)/i;
+var HTML_BLOCK_1_CLOSE = /<\/(?:script|pre|style|textarea)>/i;
+var HTML_BLOCK_2_OPEN = /^<!--/;
+var HTML_BLOCK_2_CLOSE = /-->/;
+var HTML_BLOCK_3_OPEN = /^<\?/;
+var HTML_BLOCK_3_CLOSE = /\?>/;
+var HTML_BLOCK_4_OPEN = /^<![A-Z]/;
+var HTML_BLOCK_4_CLOSE = />/;
+var HTML_BLOCK_5_OPEN = /^<!\[CDATA\[/;
+var HTML_BLOCK_5_CLOSE = /\]\]>/;
+var HTML_BLOCK_6_OPEN = /^<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|\/?>|$)/i;
+var HTML_BLOCK_7_OPEN = /^(?:<[a-zA-Z][a-zA-Z0-9-]*(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^"'=<>`\s]+|'[^']*'|"[^"]*"))?)*\s*\/?>|<\/[a-zA-Z][a-zA-Z0-9-]*\s*>)[ \t]*$/;
+function getHtmlBlockType(line) {
+  if (HTML_BLOCK_1_OPEN.test(line))
+    return 1;
+  if (HTML_BLOCK_2_OPEN.test(line))
+    return 2;
+  if (HTML_BLOCK_3_OPEN.test(line))
+    return 3;
+  if (HTML_BLOCK_4_OPEN.test(line))
+    return 4;
+  if (HTML_BLOCK_5_OPEN.test(line))
+    return 5;
+  if (HTML_BLOCK_6_OPEN.test(line))
+    return 6;
+  if (HTML_BLOCK_7_OPEN.test(line))
+    return 7;
+  return 0;
+}
+function closesHtmlBlock(line, type) {
+  switch (type) {
+    case 1:
+      return HTML_BLOCK_1_CLOSE.test(line);
+    case 2:
+      return HTML_BLOCK_2_CLOSE.test(line);
+    case 3:
+      return HTML_BLOCK_3_CLOSE.test(line);
+    case 4:
+      return HTML_BLOCK_4_CLOSE.test(line);
+    case 5:
+      return HTML_BLOCK_5_CLOSE.test(line);
+    case 6:
+    case 7:
+      return isBlankLine(line);
+    default:
+      return false;
+  }
+}
+
+// src/inline-parser.ts
+function tokenize(text) {
+  const tokens = [];
+  let i = 0;
+  let textStart = 0;
+  const pushText = (end) => {
+    if (end > textStart) {
+      tokens.push({
+        type: "text",
+        value: text.slice(textStart, end),
+        start: textStart,
+        end
+      });
+    }
+  };
+  while (i < text.length) {
+    const char = text[i];
+    if (char === "\\") {
+      if (i + 1 < text.length) {
+        const nextChar = text[i + 1];
+        if (nextChar === `
+`) {
+          pushText(i);
+          tokens.push({ type: "hardBreak", start: i, end: i + 2 });
+          i += 2;
+          textStart = i;
+          continue;
+        }
+        if (nextChar && "\\!\"#$%&'()*+,-./:;<=>?@[]^_`{|}~".includes(nextChar)) {
+          pushText(i);
+          tokens.push({
+            type: "text",
+            value: nextChar,
+            start: i,
+            end: i + 2
+          });
+          i += 2;
+          textStart = i;
+          continue;
+        }
+      }
+      i++;
+      continue;
+    }
+    if (char === "`") {
+      const codeSpan = parseCodeSpan(text, i);
+      if (codeSpan) {
+        pushText(i);
+        tokens.push(codeSpan);
+        i = codeSpan.end;
+        textStart = i;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (char === "<") {
+      const autolink = parseAutolink(text, i);
+      if (autolink) {
+        pushText(i);
+        tokens.push(autolink);
+        i = autolink.end;
+        textStart = i;
+        continue;
+      }
+      const htmlInline = parseHtmlInline(text, i);
+      if (htmlInline) {
+        pushText(i);
+        tokens.push(htmlInline);
+        i = htmlInline.end;
+        textStart = i;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (char === `
+`) {
+      pushText(i);
+      const prevText = text.slice(textStart, i);
+      if (prevText.endsWith("  ")) {
+        if (tokens.length > 0 && tokens[tokens.length - 1]?.type === "text") {
+          const lastToken = tokens[tokens.length - 1];
+          lastToken.value = lastToken.value.replace(/ {2,}$/, "");
+        }
+        tokens.push({ type: "hardBreak", start: i, end: i + 1 });
+      } else {
+        tokens.push({ type: "softBreak", start: i, end: i + 1 });
+      }
+      i++;
+      textStart = i;
+      continue;
+    }
+    if (char === "*" || char === "_") {
+      const run = parseDelimiterRun(text, i, char);
+      if (run) {
+        pushText(i);
+        tokens.push(run);
+        i = run.end;
+        textStart = i;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (char === "[") {
+      pushText(i);
+      const isImage = i > 0 && text[i - 1] === "!";
+      if (isImage && tokens.length > 0) {
+        const lastToken = tokens[tokens.length - 1];
+        if (lastToken?.type === "text" && lastToken.value.endsWith("!")) {
+          lastToken.value = lastToken.value.slice(0, -1);
+          if (lastToken.value === "") {
+            tokens.pop();
+          }
+        }
+      }
+      tokens.push({
+        type: "openBracket",
+        isImage,
+        start: isImage ? i - 1 : i,
+        end: i + 1
+      });
+      i++;
+      textStart = i;
+      continue;
+    }
+    if (char === "]") {
+      pushText(i);
+      tokens.push({ type: "closeBracket", start: i, end: i + 1 });
+      i++;
+      textStart = i;
+      if (i < text.length && text[i] === "(") {
+        const linkInfo = parseLinkDestination(text, i);
+        if (linkInfo) {
+          tokens.push(linkInfo);
+          i = linkInfo.end;
+          textStart = i;
+        }
+      } else if (i < text.length && text[i] === "[") {
+        const refEnd = text.indexOf("]", i + 1);
+        if (refEnd > i + 1) {
+          const ref = text.slice(i + 1, refEnd);
+          tokens.push({
+            type: "linkInfo",
+            url: "",
+            title: ref,
+            start: i,
+            end: refEnd + 1
+          });
+          i = refEnd + 1;
+          textStart = i;
+        }
+      }
+      continue;
+    }
+    i++;
+  }
+  pushText(text.length);
+  return tokens;
+}
+function parseCodeSpan(text, start) {
+  let backticks = 0;
+  let i = start;
+  while (i < text.length && text[i] === "`") {
+    backticks++;
+    i++;
+  }
+  if (backticks === 0)
+    return null;
+  const closingPattern = "`".repeat(backticks);
+  let searchStart = i;
+  while (searchStart < text.length) {
+    const closingIndex = text.indexOf(closingPattern, searchStart);
+    if (closingIndex === -1)
+      return null;
+    const afterClosing = closingIndex + backticks;
+    if ((closingIndex === searchStart || text[closingIndex - 1] !== "`") && (afterClosing >= text.length || text[afterClosing] !== "`")) {
+      let content = text.slice(i, closingIndex);
+      content = content.replace(/\n/g, " ");
+      if (content.length >= 2 && content.startsWith(" ") && content.endsWith(" ") && !/^ +$/.test(content)) {
+        content = content.slice(1, -1);
+      }
+      return {
+        type: "code",
+        value: content,
+        start,
+        end: afterClosing
+      };
+    }
+    searchStart = closingIndex + 1;
+  }
+  return null;
+}
+function parseAutolink(text, start) {
+  if (text[start] !== "<")
+    return null;
+  const closingIndex = text.indexOf(">", start + 1);
+  if (closingIndex === -1)
+    return null;
+  const content = text.slice(start, closingIndex + 1);
+  const urlMatch = AUTOLINK_REGEX.exec(content);
+  if (urlMatch && urlMatch[1]) {
+    return {
+      type: "autolink",
+      url: urlMatch[1],
+      isEmail: false,
+      start,
+      end: closingIndex + 1
+    };
+  }
+  const emailMatch = EMAIL_AUTOLINK_REGEX.exec(content);
+  if (emailMatch && emailMatch[1]) {
+    return {
+      type: "autolink",
+      url: `mailto:${emailMatch[1]}`,
+      isEmail: true,
+      start,
+      end: closingIndex + 1
+    };
+  }
+  return null;
+}
+function parseHtmlInline(text, start) {
+  if (text[start] !== "<")
+    return null;
+  const remaining = text.slice(start);
+  const openTagMatch = /^<[a-zA-Z][a-zA-Z0-9-]*(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^"'=<>`\s]+|'[^']*'|"[^"]*"))?)*\s*\/?>/.exec(remaining);
+  if (openTagMatch) {
+    return {
+      type: "htmlInline",
+      value: openTagMatch[0],
+      start,
+      end: start + openTagMatch[0].length
+    };
+  }
+  const closeTagMatch = /^<\/[a-zA-Z][a-zA-Z0-9-]*\s*>/.exec(remaining);
+  if (closeTagMatch) {
+    return {
+      type: "htmlInline",
+      value: closeTagMatch[0],
+      start,
+      end: start + closeTagMatch[0].length
+    };
+  }
+  const commentMatch = /^<!--(?!-?>)(?:[^-]|-(?!-))*-->/.exec(remaining);
+  if (commentMatch) {
+    return {
+      type: "htmlInline",
+      value: commentMatch[0],
+      start,
+      end: start + commentMatch[0].length
+    };
+  }
+  const piMatch = /^<\?.*?\?>/.exec(remaining);
+  if (piMatch) {
+    return {
+      type: "htmlInline",
+      value: piMatch[0],
+      start,
+      end: start + piMatch[0].length
+    };
+  }
+  const declMatch = /^<![A-Z]+\s+[^>]*>/.exec(remaining);
+  if (declMatch) {
+    return {
+      type: "htmlInline",
+      value: declMatch[0],
+      start,
+      end: start + declMatch[0].length
+    };
+  }
+  const cdataMatch = /^<!\[CDATA\[[\s\S]*?\]\]>/.exec(remaining);
+  if (cdataMatch) {
+    return {
+      type: "htmlInline",
+      value: cdataMatch[0],
+      start,
+      end: start + cdataMatch[0].length
+    };
+  }
+  return null;
+}
+function parseDelimiterRun(text, start, char) {
+  let count = 0;
+  let i = start;
+  while (i < text.length && text[i] === char) {
+    count++;
+    i++;
+  }
+  if (count === 0)
+    return null;
+  const before = start > 0 ? text[start - 1] : " ";
+  const after = i < text.length ? text[i] : " ";
+  const beforeWhitespace = /\s/.test(before ?? " ");
+  const afterWhitespace = /\s/.test(after ?? " ");
+  const beforePunct = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/.test(before ?? "");
+  const afterPunct = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/.test(after ?? "");
+  const leftFlanking = !afterWhitespace && (!afterPunct || beforeWhitespace || beforePunct);
+  const rightFlanking = !beforeWhitespace && (!beforePunct || afterWhitespace || afterPunct);
+  let canOpen;
+  let canClose;
+  if (char === "*") {
+    canOpen = leftFlanking;
+    canClose = rightFlanking;
+  } else {
+    canOpen = leftFlanking && (!rightFlanking || beforePunct);
+    canClose = rightFlanking && (!leftFlanking || afterPunct);
+  }
+  return {
+    type: "delimiterRun",
+    char,
+    count,
+    start,
+    end: i,
+    canOpen,
+    canClose
+  };
+}
+function parseLinkDestination(text, start) {
+  if (text[start] !== "(")
+    return null;
+  let i = start + 1;
+  while (i < text.length && /\s/.test(text[i] ?? "")) {
+    i++;
+  }
+  if (i >= text.length)
+    return null;
+  let url = "";
+  let title;
+  if (text[i] === "<") {
+    const closeBracket = text.indexOf(">", i + 1);
+    if (closeBracket === -1)
+      return null;
+    const urlContent = text.slice(i + 1, closeBracket);
+    if (urlContent.includes("<") || urlContent.includes(`
+`))
+      return null;
+    url = urlContent;
+    i = closeBracket + 1;
+  } else {
+    let parenDepth = 0;
+    const urlStart = i;
+    while (i < text.length) {
+      const char = text[i];
+      if (char === " " || char === "\t" || char === `
+`)
+        break;
+      if (char === "(") {
+        parenDepth++;
+      } else if (char === ")") {
+        if (parenDepth === 0)
+          break;
+        parenDepth--;
+      }
+      if (char === "\\" && i + 1 < text.length) {
+        i += 2;
+        continue;
+      }
+      if (char && char.charCodeAt(0) < 32)
+        return null;
+      i++;
+    }
+    url = text.slice(urlStart, i);
+  }
+  while (i < text.length && /\s/.test(text[i] ?? "")) {
+    i++;
+  }
+  if (i < text.length && (text[i] === '"' || text[i] === "'" || text[i] === "(")) {
+    const titleChar = text[i] === "(" ? ")" : text[i];
+    const titleStart = i + 1;
+    i++;
+    let escaped = false;
+    while (i < text.length) {
+      if (escaped) {
+        escaped = false;
+        i++;
+        continue;
+      }
+      if (text[i] === "\\") {
+        escaped = true;
+        i++;
+        continue;
+      }
+      if (text[i] === titleChar) {
+        title = text.slice(titleStart, i);
+        i++;
+        break;
+      }
+      i++;
+    }
+    if (title === undefined)
+      return null;
+  }
+  while (i < text.length && /\s/.test(text[i] ?? "")) {
+    i++;
+  }
+  if (text[i] !== ")")
+    return null;
+  return {
+    type: "linkInfo",
+    url: decodeHtmlEntities(unescapeMarkdown(url)),
+    title: title ? decodeHtmlEntities(unescapeMarkdown(title)) : undefined,
+    start,
+    end: i + 1
+  };
+}
+function findEmphasisMatches(delimiters) {
+  const matches = [];
+  for (let closeIdx = 0;closeIdx < delimiters.length; closeIdx++) {
+    const closer = delimiters[closeIdx];
+    if (!closer || !closer.canClose || closer.count === 0)
+      continue;
+    for (let openIdx = closeIdx - 1;openIdx >= 0; openIdx--) {
+      const opener = delimiters[openIdx];
+      if (!opener || !opener.canOpen || opener.count === 0)
+        continue;
+      if (opener.char !== closer.char)
+        continue;
+      if (opener.canOpen && opener.canClose || closer.canOpen && closer.canClose) {
+        if ((opener.count + closer.count) % 3 === 0) {
+          if (opener.count % 3 !== 0 || closer.count % 3 !== 0) {
+            continue;
+          }
+        }
+      }
+      const useStrong = opener.count >= 2 && closer.count >= 2;
+      const used = useStrong ? 2 : 1;
+      matches.push({
+        openerIdx: openIdx,
+        closerIdx: closeIdx,
+        count: used
+      });
+      opener.count -= used;
+      closer.count -= used;
+      if (closer.count > 0) {}
+      break;
+    }
+  }
+  return matches;
+}
+function tokensToNodes(tokens, references) {
+  const delimiters = [];
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token?.type === "delimiterRun") {
+      delimiters.push({
+        char: token.char,
+        count: token.count,
+        position: i,
+        canOpen: token.canOpen,
+        canClose: token.canClose,
+        active: true,
+        tokenIndex: i
+      });
+    }
+  }
+  const matches = findEmphasisMatches(delimiters);
+  matches.sort((a, b) => b.openerIdx - a.openerIdx);
+  const bracketStack = [];
+  const usedDelimiters = new Map;
+  for (const match of matches) {
+    const opener = delimiters[match.openerIdx];
+    const closer = delimiters[match.closerIdx];
+    if (!opener || !closer)
+      continue;
+    const openerUsed = usedDelimiters.get(opener.tokenIndex) ?? [];
+    openerUsed.push(match.count);
+    usedDelimiters.set(opener.tokenIndex, openerUsed);
+    const closerUsed = usedDelimiters.get(closer.tokenIndex) ?? [];
+    closerUsed.push(match.count);
+    usedDelimiters.set(closer.tokenIndex, closerUsed);
+  }
+  function processTokenRange(start, end, _emphasisStack) {
+    const result = [];
+    let i = start;
+    while (i < end) {
+      const token = tokens[i];
+      if (!token) {
+        i++;
+        continue;
+      }
+      switch (token.type) {
+        case "text":
+          result.push({
+            type: "text",
+            value: decodeHtmlEntities(unescapeMarkdown(token.value))
+          });
+          break;
+        case "code":
+          result.push({
+            type: "codeSpan",
+            value: token.value
+          });
+          break;
+        case "hardBreak":
+          result.push({ type: "hardBreak" });
+          break;
+        case "softBreak":
+          result.push({ type: "softBreak" });
+          break;
+        case "autolink":
+          result.push({
+            type: "link",
+            url: token.url,
+            children: [
+              { type: "text", value: token.url.replace(/^mailto:/, "") }
+            ]
+          });
+          break;
+        case "htmlInline":
+          result.push({
+            type: "htmlInline",
+            value: token.value
+          });
+          break;
+        case "delimiterRun": {
+          const delimIdx = delimiters.findIndex((d) => d.tokenIndex === i);
+          const delim = delimiters[delimIdx];
+          if (delim) {
+            let remaining = token.count;
+            for (const match of matches) {
+              if (match.openerIdx === delimIdx && remaining >= match.count) {
+                const closerDelim = delimiters[match.closerIdx];
+                if (closerDelim) {
+                  const closerTokenIdx = closerDelim.tokenIndex;
+                  const innerNodes = processTokenRange(i + 1, closerTokenIdx, []);
+                  const emphNode = match.count === 2 ? {
+                    type: "strong",
+                    children: innerNodes,
+                    marker: token.char + token.char
+                  } : {
+                    type: "emphasis",
+                    children: innerNodes,
+                    marker: token.char
+                  };
+                  result.push(emphNode);
+                  remaining -= match.count;
+                  i = closerTokenIdx;
+                }
+              }
+            }
+            if (remaining > 0) {
+              result.push({
+                type: "text",
+                value: token.char.repeat(remaining)
+              });
+            }
+          } else {
+            result.push({
+              type: "text",
+              value: token.char.repeat(token.count)
+            });
+          }
+          break;
+        }
+        case "openBracket":
+          bracketStack.push({
+            position: result.length,
+            isImage: token.isImage,
+            delimiterIndex: -1,
+            active: true
+          });
+          result.push({ type: "text", value: token.isImage ? "![" : "[" });
+          break;
+        case "closeBracket": {
+          let matched = false;
+          for (let j = bracketStack.length - 1;j >= 0; j--) {
+            const bracket = bracketStack[j];
+            if (!bracket || !bracket.active)
+              continue;
+            const nextToken = tokens[i + 1];
+            if (nextToken?.type === "linkInfo") {
+              const linkContent = result.slice(bracket.position + 1);
+              result.length = bracket.position;
+              let url = nextToken.url;
+              let title = nextToken.title;
+              if (!url && title) {
+                const ref = references.get(normalizeLabel(title));
+                if (ref) {
+                  url = ref.url;
+                  title = ref.title;
+                }
+              }
+              if (bracket.isImage) {
+                const alt = linkContent.map((n) => {
+                  if (n.type === "text")
+                    return n.value;
+                  if (n.type === "codeSpan")
+                    return n.value;
+                  return "";
+                }).join("");
+                result.push({
+                  type: "image",
+                  alt,
+                  url,
+                  title
+                });
+              } else {
+                result.push({
+                  type: "link",
+                  url,
+                  title,
+                  children: linkContent
+                });
+              }
+              i++;
+              matched = true;
+            } else {
+              const linkText = result.slice(bracket.position + 1).map((n) => n.type === "text" ? n.value : "").join("");
+              const ref = references.get(normalizeLabel(linkText));
+              if (ref) {
+                const linkContent = result.slice(bracket.position + 1);
+                result.length = bracket.position;
+                if (bracket.isImage) {
+                  result.push({
+                    type: "image",
+                    alt: linkText,
+                    url: ref.url,
+                    title: ref.title
+                  });
+                } else {
+                  result.push({
+                    type: "link",
+                    url: ref.url,
+                    title: ref.title,
+                    children: linkContent
+                  });
+                }
+                matched = true;
+              }
+            }
+            bracket.active = false;
+            break;
+          }
+          if (!matched) {
+            result.push({ type: "text", value: "]" });
+          }
+          break;
+        }
+        case "linkInfo":
+          result.push({ type: "text", value: `(${token.url})` });
+          break;
+      }
+      i++;
+    }
+    return mergeTextNodes(result);
+  }
+  return processTokenRange(0, tokens.length, []);
+}
+function mergeTextNodes(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (node.type === "text" && result.length > 0) {
+      const last = result[result.length - 1];
+      if (last?.type === "text") {
+        last.value += node.value;
+        continue;
+      }
+    }
+    result.push(node);
+  }
+  return result;
+}
+function parseInline(text, references = new Map) {
+  if (!text)
+    return [];
+  const tokens = tokenize(text);
+  return tokensToNodes(tokens, references);
+}
+
+// src/block-parser.ts
+function createBlockContext() {
+  return {
+    lineNumber: 1,
+    column: 1,
+    indent: 0,
+    tight: true,
+    inBlockquote: false,
+    listDepth: 0,
+    blockquoteDepth: 0,
+    references: new Map
+  };
+}
+function createPosition(startLine, endLine) {
+  return {
+    startLine: startLine.lineNumber,
+    startColumn: 1,
+    endLine: endLine.lineNumber,
+    endColumn: endLine.raw.length + 1,
+    startOffset: startLine.offset,
+    endOffset: endLine.offset + endLine.raw.length
+  };
+}
+function isThematicBreak(line) {
+  return THEMATIC_BREAK_REGEX.test(line.trim());
+}
+function isAtxHeading(line) {
+  return ATX_HEADING_REGEX.exec(line.trim());
+}
+function isSetextUnderline(line) {
+  return SETEXT_HEADING_REGEX.exec(line.trim());
+}
+function isFencedCodeStart(line) {
+  const trimmed = line.trimStart();
+  const indent = countIndent(line);
+  if (indent >= 4)
+    return null;
+  return FENCED_CODE_OPEN_REGEX.exec(trimmed);
+}
+function isBlockquoteStart(line) {
+  return BLOCKQUOTE_REGEX.test(line.trimStart());
+}
+function isListItemStart(line) {
+  const trimmed = line.trimStart();
+  const leadingIndent = countIndent(line);
+  const ordered = ORDERED_LIST_REGEX.exec(trimmed);
+  if (ordered) {
+    return {
+      ordered: true,
+      marker: ordered[2],
+      start: Number.parseInt(ordered[1] ?? "1", 10),
+      indent: leadingIndent + (ordered[0]?.length ?? 0)
+    };
+  }
+  const unordered = UNORDERED_LIST_REGEX.exec(trimmed);
+  if (unordered) {
+    return {
+      ordered: false,
+      marker: unordered[1],
+      indent: leadingIndent + (unordered[0]?.length ?? 0)
+    };
+  }
+  return null;
+}
+function isLinkReferenceDefinition(line) {
+  const match = LINK_REFERENCE_REGEX.exec(line.trim());
+  if (!match)
+    return null;
+  return {
+    label: match[1] ?? "",
+    url: match[2] ?? "",
+    title: match[3] ?? match[4] ?? match[5]
+  };
+}
+var TABLE_DELIMITER_REGEX = /^\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+function isTableRow(line) {
+  const trimmed = line.trim();
+  return trimmed.includes("|");
+}
+function isTableDelimiter(line) {
+  return TABLE_DELIMITER_REGEX.test(line.trim());
+}
+function parseAlignment(cell) {
+  const trimmed = cell.trim();
+  const hasLeft = trimmed.startsWith(":");
+  const hasRight = trimmed.endsWith(":");
+  if (hasLeft && hasRight)
+    return "center";
+  if (hasRight)
+    return "right";
+  if (hasLeft)
+    return "left";
+  return null;
+}
+function splitTableRow(line) {
+  let content = line.trim();
+  if (content.startsWith("|"))
+    content = content.slice(1);
+  if (content.endsWith("|"))
+    content = content.slice(0, -1);
+  const cells = [];
+  let current = "";
+  let escaped = false;
+  for (const char of content) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+      current += char;
+    } else if (char === "|") {
+      cells.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current.trim());
+  return cells;
+}
+var MAX_NESTING_DEPTH = 100;
+function collectReferences(lines, context) {
+  for (const line of lines) {
+    if (isBlankLine(line.raw))
+      continue;
+    const refMatch = isLinkReferenceDefinition(line.raw);
+    if (refMatch) {
+      const normalizedLabel = refMatch.label.toLowerCase().replace(/\s+/g, " ");
+      context.references.set(normalizedLabel, {
+        url: refMatch.url,
+        title: refMatch.title
+      });
+    }
+  }
+}
+function parseBlocks(content, context, includePositions = true, depth = 0) {
+  if (depth > MAX_NESTING_DEPTH) {
+    return { blocks: [], references: context?.references ?? new Map };
+  }
+  const ctx = context ?? createBlockContext();
+  const lines = splitLines(content);
+  collectReferences(lines, ctx);
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const result = parseBlock(lines, i, ctx, includePositions, depth);
+    if (result.block) {
+      blocks.push(result.block);
+    }
+    i += result.consumed;
+  }
+  return { blocks, references: ctx.references };
+}
+function parseBlock(lines, startIndex, context, includePositions, depth) {
+  const line = lines[startIndex];
+  if (!line) {
+    return { block: null, consumed: 1 };
+  }
+  if (line.isBlank) {
+    return { block: null, consumed: 1 };
+  }
+  const content = line.content;
+  if (isThematicBreak(content)) {
+    return parseThematicBreak(line, includePositions);
+  }
+  const atxMatch = isAtxHeading(content);
+  if (atxMatch) {
+    return parseAtxHeading(line, atxMatch, context, includePositions);
+  }
+  const fenceMatch = isFencedCodeStart(line.raw);
+  if (fenceMatch) {
+    return parseFencedCodeBlock(lines, startIndex, fenceMatch, includePositions);
+  }
+  const htmlType = getHtmlBlockType(content);
+  if (htmlType > 0 && line.indent < 4) {
+    return parseHtmlBlock(lines, startIndex, htmlType, includePositions);
+  }
+  if (isBlockquoteStart(line.raw)) {
+    return parseBlockquote(lines, startIndex, context, includePositions, depth);
+  }
+  const listMatch = isListItemStart(line.raw);
+  if (listMatch) {
+    return parseList(lines, startIndex, listMatch, context, includePositions, depth);
+  }
+  if (line.indent >= 4 && !context.inBlockquote) {
+    return parseIndentedCodeBlock(lines, startIndex, includePositions);
+  }
+  if (isTableRow(line.content)) {
+    const tableResult = parseTable(lines, startIndex, context, includePositions);
+    if (tableResult.block) {
+      return tableResult;
+    }
+  }
+  const refMatch = isLinkReferenceDefinition(line.raw);
+  if (refMatch) {
+    const normalizedLabel = refMatch.label.toLowerCase().replace(/\s+/g, " ");
+    context.references.set(normalizedLabel, {
+      url: refMatch.url,
+      title: refMatch.title
+    });
+    return { block: null, consumed: 1 };
+  }
+  return parseParagraph(lines, startIndex, context, includePositions);
+}
+function parseThematicBreak(line, includePositions) {
+  const content = line.content.trim();
+  let marker = "-";
+  if (content.includes("*"))
+    marker = "*";
+  else if (content.includes("_"))
+    marker = "_";
+  const node = {
+    type: "thematicBreak",
+    marker
+  };
+  if (includePositions) {
+    node.position = createPosition(line, line);
+  }
+  return { block: node, consumed: 1 };
+}
+function parseAtxHeading(line, match, context, includePositions) {
+  const level = match[1]?.length ?? 1;
+  let text = match[2] ?? "";
+  text = text.replace(/[ \t]+#+[ \t]*$/, "").replace(/#+[ \t]*$/, "").trim();
+  const node = {
+    type: "heading",
+    level,
+    children: parseInline(text, context.references),
+    style: "atx"
+  };
+  if (includePositions) {
+    node.position = createPosition(line, line);
+  }
+  return { block: node, consumed: 1 };
+}
+function parseFencedCodeBlock(lines, startIndex, match, includePositions) {
+  const startLine = lines[startIndex];
+  if (!startLine) {
+    return {
+      block: {
+        type: "codeBlock",
+        value: "",
+        style: "fenced",
+        fence: "`",
+        fenceLength: 3
+      },
+      consumed: 1
+    };
+  }
+  const fence = match[1]?.[0];
+  const fenceLength = match[1]?.length ?? 3;
+  const infoString = (match[2] ?? "").trim();
+  const spaceIndex = infoString.indexOf(" ");
+  let lang;
+  let meta;
+  if (infoString) {
+    if (spaceIndex > 0) {
+      lang = infoString.slice(0, spaceIndex);
+      meta = infoString.slice(spaceIndex + 1).trim();
+    } else {
+      lang = infoString;
+    }
+  }
+  const indent = countIndent(startLine.raw);
+  const contentLines = [];
+  let i = startIndex + 1;
+  const closingFenceRegex = new RegExp(`^${fence}{${fenceLength},}[ \\t]*$`);
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    const lineIndent = countIndent(line.raw);
+    const trimmed = line.raw.trimStart();
+    if (closingFenceRegex.test(trimmed) && lineIndent < 4) {
+      i++;
+      break;
+    }
+    const contentLine = removeIndent(line.raw, Math.min(indent, line.indent));
+    contentLines.push(contentLine);
+    i++;
+  }
+  const node = {
+    type: "codeBlock",
+    value: contentLines.join(`
+`),
+    style: "fenced",
+    fence,
+    fenceLength
+  };
+  if (lang)
+    node.lang = lang;
+  if (meta)
+    node.meta = meta;
+  if (includePositions) {
+    const endLine = lines[i - 1] ?? startLine;
+    node.position = createPosition(startLine, endLine);
+  }
+  return { block: node, consumed: i - startIndex };
+}
+function parseIndentedCodeBlock(lines, startIndex, includePositions) {
+  const contentLines = [];
+  let i = startIndex;
+  let lastNonBlankIndex = startIndex;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    if (line.isBlank) {
+      contentLines.push("");
+      i++;
+      continue;
+    }
+    if (line.indent < 4) {
+      break;
+    }
+    contentLines.push(removeIndent(line.raw, 4));
+    lastNonBlankIndex = i;
+    i++;
+  }
+  const trimmedContent = contentLines.slice(0, lastNonBlankIndex - startIndex + 1);
+  const node = {
+    type: "codeBlock",
+    value: trimmedContent.join(`
+`),
+    style: "indented"
+  };
+  if (includePositions) {
+    const startLine = lines[startIndex];
+    const endLine = lines[lastNonBlankIndex] ?? startLine;
+    if (startLine && endLine) {
+      node.position = createPosition(startLine, endLine);
+    }
+  }
+  return { block: node, consumed: i - startIndex };
+}
+function parseTable(lines, startIndex, context, includePositions) {
+  if (startIndex + 1 >= lines.length) {
+    return { block: null, consumed: 0 };
+  }
+  const headerLine = lines[startIndex];
+  const delimiterLine = lines[startIndex + 1];
+  if (!headerLine || !delimiterLine) {
+    return { block: null, consumed: 0 };
+  }
+  if (!isTableRow(headerLine.content) || !isTableDelimiter(delimiterLine.content)) {
+    return { block: null, consumed: 0 };
+  }
+  const headerCells = splitTableRow(headerLine.content);
+  const delimiterCells = splitTableRow(delimiterLine.content);
+  if (headerCells.length !== delimiterCells.length || headerCells.length === 0) {
+    return { block: null, consumed: 0 };
+  }
+  for (const cell of delimiterCells) {
+    if (!/^:?-+:?$/.test(cell.trim())) {
+      return { block: null, consumed: 0 };
+    }
+  }
+  const alignments = delimiterCells.map(parseAlignment);
+  const headerRowCells = headerCells.map((cell, idx) => ({
+    type: "tableCell",
+    children: parseInline(cell, context.references),
+    align: alignments[idx] ?? undefined,
+    isHeader: true
+  }));
+  const headerRow = {
+    type: "tableRow",
+    children: headerRowCells,
+    isHeader: true
+  };
+  if (includePositions && headerLine) {
+    headerRow.position = createPosition(headerLine, headerLine);
+  }
+  const rows = [headerRow];
+  let i = startIndex + 2;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    if (line.isBlank || !isTableRow(line.content)) {
+      break;
+    }
+    if (isThematicBreak(line.content) || isAtxHeading(line.content)) {
+      break;
+    }
+    const cells = splitTableRow(line.content);
+    const rowCells = [];
+    for (let j = 0;j < headerCells.length; j++) {
+      const cellContent = cells[j] ?? "";
+      rowCells.push({
+        type: "tableCell",
+        children: parseInline(cellContent, context.references),
+        align: alignments[j] ?? undefined,
+        isHeader: false
+      });
+    }
+    const bodyRow = {
+      type: "tableRow",
+      children: rowCells,
+      isHeader: false
+    };
+    if (includePositions) {
+      bodyRow.position = createPosition(line, line);
+    }
+    rows.push(bodyRow);
+    i++;
+  }
+  const node = {
+    type: "table",
+    children: rows,
+    align: alignments
+  };
+  if (includePositions) {
+    const endLine = lines[i - 1] ?? headerLine;
+    node.position = createPosition(headerLine, endLine);
+  }
+  return { block: node, consumed: i - startIndex };
+}
+function parseHtmlBlock(lines, startIndex, htmlType, includePositions) {
+  const contentLines = [];
+  let i = startIndex;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    contentLines.push(line.raw);
+    if (closesHtmlBlock(line.raw, htmlType)) {
+      if (htmlType === 6 || htmlType === 7) {
+        contentLines.pop();
+      }
+      i++;
+      break;
+    }
+    i++;
+  }
+  const node = {
+    type: "htmlBlock",
+    value: contentLines.join(`
+`),
+    htmlType
+  };
+  if (includePositions) {
+    const startLine = lines[startIndex];
+    const endLine = lines[i - 1] ?? startLine;
+    if (startLine && endLine) {
+      node.position = createPosition(startLine, endLine);
+    }
+  }
+  return { block: node, consumed: i - startIndex };
+}
+function parseBlockquote(lines, startIndex, context, includePositions, depth) {
+  const quoteLines = [];
+  let i = startIndex;
+  let hadBlankLine = false;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    const match = BLOCKQUOTE_REGEX.exec(line.raw.trimStart());
+    if (match) {
+      const content = line.raw.trimStart().slice(match[0].length);
+      quoteLines.push(content);
+      i++;
+      continue;
+    }
+    if (!line.isBlank && !hadBlankLine) {
+      quoteLines.push(line.raw);
+      i++;
+      continue;
+    }
+    if (line.isBlank) {
+      hadBlankLine = true;
+      const nextLine = lines[i + 1];
+      if (nextLine && BLOCKQUOTE_REGEX.test(nextLine.raw.trimStart())) {
+        quoteLines.push("");
+        i++;
+        continue;
+      }
+    }
+    break;
+  }
+  const innerContent = quoteLines.join(`
+`);
+  const innerContext = {
+    ...context,
+    inBlockquote: true,
+    blockquoteDepth: context.blockquoteDepth + 1
+  };
+  const { blocks } = parseBlocks(innerContent, innerContext, includePositions, depth + 1);
+  const node = {
+    type: "blockquote",
+    children: blocks
+  };
+  if (includePositions) {
+    const startLine = lines[startIndex];
+    const endLine = lines[i - 1];
+    if (startLine && endLine) {
+      node.position = createPosition(startLine, endLine);
+    }
+  }
+  return { block: node, consumed: i - startIndex };
+}
+function parseList(lines, startIndex, firstItem, context, includePositions, depth) {
+  const items = [];
+  let i = startIndex;
+  let spread = false;
+  let hadBlankBetweenItems = false;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    if (line.isBlank) {
+      hadBlankBetweenItems = true;
+      i++;
+      continue;
+    }
+    const itemMatch = isListItemStart(line.raw);
+    if (itemMatch) {
+      const sameType = itemMatch.ordered === firstItem.ordered;
+      const sameMarkerFamily = firstItem.ordered || itemMatch.marker === firstItem.marker || ["-", "*", "+"].includes(itemMatch.marker);
+      if (!sameType || !sameMarkerFamily) {
+        break;
+      }
+      const { item, consumed } = parseListItem(lines, i, itemMatch.indent, itemMatch.marker, context, includePositions, depth);
+      if (hadBlankBetweenItems && items.length > 0) {
+        spread = true;
+      }
+      items.push(item);
+      i += consumed;
+      hadBlankBetweenItems = false;
+      continue;
+    }
+    if (line.indent >= firstItem.indent) {
+      break;
+    }
+    break;
+  }
+  const node = {
+    type: "list",
+    ordered: firstItem.ordered,
+    children: items,
+    marker: firstItem.marker,
+    spread
+  };
+  if (firstItem.ordered && firstItem.start !== undefined) {
+    node.start = firstItem.start;
+  }
+  if (includePositions) {
+    const startLine = lines[startIndex];
+    const endLine = lines[i - 1];
+    if (startLine && endLine) {
+      node.position = createPosition(startLine, endLine);
+    }
+  }
+  return { block: node, consumed: i - startIndex };
+}
+function parseListItem(lines, startIndex, itemIndent, marker, context, includePositions, depth) {
+  const itemLines = [];
+  let i = startIndex;
+  let hasBlank = false;
+  let spread = false;
+  const firstLine = lines[startIndex];
+  if (firstLine) {
+    const match = ORDERED_LIST_REGEX.exec(firstLine.raw.trimStart()) ?? UNORDERED_LIST_REGEX.exec(firstLine.raw.trimStart());
+    if (match) {
+      const content = firstLine.raw.trimStart().slice(match[0].length);
+      itemLines.push(content);
+    }
+  }
+  i++;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    if (line.isBlank) {
+      hasBlank = true;
+      itemLines.push("");
+      i++;
+      continue;
+    }
+    const itemMatch = isListItemStart(line.raw);
+    if (itemMatch && line.indent < itemIndent) {
+      break;
+    }
+    if (line.indent >= itemIndent) {
+      if (hasBlank) {
+        spread = true;
+      }
+      itemLines.push(removeIndent(line.raw, itemIndent));
+      i++;
+      continue;
+    }
+    if (itemMatch) {
+      break;
+    }
+    if (!hasBlank) {
+      itemLines.push(line.raw);
+      i++;
+      continue;
+    }
+    break;
+  }
+  while (itemLines.length > 0 && itemLines[itemLines.length - 1] === "") {
+    itemLines.pop();
+  }
+  const innerContent = itemLines.join(`
+`);
+  const innerContext = {
+    ...context,
+    listDepth: context.listDepth + 1
+  };
+  const { blocks } = parseBlocks(innerContent, innerContext, includePositions, depth + 1);
+  const node = {
+    type: "listItem",
+    children: blocks,
+    marker,
+    spread
+  };
+  if (includePositions) {
+    const startLine = lines[startIndex];
+    const endLine = lines[i - 1];
+    if (startLine && endLine) {
+      node.position = createPosition(startLine, endLine);
+    }
+  }
+  return { item: node, consumed: i - startIndex };
+}
+function parseParagraph(lines, startIndex, context, includePositions) {
+  const paragraphLines = [];
+  let i = startIndex;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line)
+      break;
+    if (line.isBlank) {
+      break;
+    }
+    if (paragraphLines.length > 0) {
+      const setextMatch = isSetextUnderline(line.content);
+      if (setextMatch && line.indent < 4) {
+        const level = setextMatch[1]?.[0] === "=" ? 1 : 2;
+        const text2 = paragraphLines.join(`
+`).trim();
+        const node2 = {
+          type: "heading",
+          level,
+          children: parseInline(text2, context.references),
+          style: "setext"
+        };
+        if (includePositions) {
+          const startLine = lines[startIndex];
+          if (startLine) {
+            node2.position = createPosition(startLine, line);
+          }
+        }
+        return { block: node2, consumed: i - startIndex + 1 };
+      }
+    }
+    if (isThematicBreak(line.content) || isAtxHeading(line.content) || isFencedCodeStart(line.raw) || getHtmlBlockType(line.content) > 0 && line.indent < 4 || isBlockquoteStart(line.raw)) {
+      break;
+    }
+    const listMatch = isListItemStart(line.raw);
+    if (listMatch) {
+      if (!listMatch.ordered || listMatch.start === 1) {
+        break;
+      }
+    }
+    paragraphLines.push(line.content);
+    i++;
+  }
+  if (paragraphLines.length === 0) {
+    return { block: null, consumed: 1 };
+  }
+  const text = paragraphLines.join(`
+`).trim();
+  const node = {
+    type: "paragraph",
+    children: parseInline(text, context.references)
+  };
+  if (includePositions) {
+    const startLine = lines[startIndex];
+    const endLine = lines[i - 1] ?? startLine;
+    if (startLine && endLine) {
+      node.position = createPosition(startLine, endLine);
+    }
+  }
+  return { block: node, consumed: i - startIndex };
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+var positionSchema = z.object({
+  startLine: z.number().int().min(1),
+  startColumn: z.number().int().min(1),
+  endLine: z.number().int().min(1),
+  endColumn: z.number().int().min(1),
+  startOffset: z.number().int().min(0),
+  endOffset: z.number().int().min(0)
+});
+var inlineNodeBase = z.object({
+  position: positionSchema.optional()
+});
+var textNodeSchema = inlineNodeBase.extend({
+  type: z.literal("text"),
+  value: z.string()
+});
+var codeSpanNodeSchema = inlineNodeBase.extend({
+  type: z.literal("codeSpan"),
+  value: z.string()
+});
+var hardBreakNodeSchema = inlineNodeBase.extend({
+  type: z.literal("hardBreak")
+});
+var softBreakNodeSchema = inlineNodeBase.extend({
+  type: z.literal("softBreak")
+});
+var htmlInlineNodeSchema = inlineNodeBase.extend({
+  type: z.literal("htmlInline"),
+  value: z.string()
+});
+var emphasisNodeSchema = inlineNodeBase.extend({
+  type: z.literal("emphasis"),
+  children: z.array(z.unknown()),
+  marker: z.enum(["*", "_"])
+});
+var strongNodeSchema = inlineNodeBase.extend({
+  type: z.literal("strong"),
+  children: z.array(z.unknown()),
+  marker: z.enum(["**", "__"])
+});
+var linkNodeSchema = inlineNodeBase.extend({
+  type: z.literal("link"),
+  url: z.string(),
+  children: z.array(z.unknown()),
+  title: z.string().optional(),
+  reference: z.string().optional()
+});
+var imageNodeSchema = inlineNodeBase.extend({
+  type: z.literal("image"),
+  alt: z.string(),
+  url: z.string(),
+  title: z.string().optional(),
+  reference: z.string().optional()
+});
+var inlineNodeSchema = z.union([
+  textNodeSchema,
+  codeSpanNodeSchema,
+  hardBreakNodeSchema,
+  softBreakNodeSchema,
+  htmlInlineNodeSchema,
+  emphasisNodeSchema,
+  strongNodeSchema,
+  linkNodeSchema,
+  imageNodeSchema
+]);
+var blockNodeBase = z.object({
+  position: positionSchema.optional()
+});
+var thematicBreakNodeSchema = blockNodeBase.extend({
+  type: z.literal("thematicBreak"),
+  marker: z.enum(["-", "*", "_"])
+});
+var headingNodeSchema = blockNodeBase.extend({
+  type: z.literal("heading"),
+  level: z.number().int().min(1).max(6),
+  children: z.array(z.unknown()),
+  style: z.enum(["atx", "setext"])
+});
+var codeBlockNodeSchema = blockNodeBase.extend({
+  type: z.literal("codeBlock"),
+  value: z.string(),
+  style: z.enum(["fenced", "indented"]),
+  lang: z.string().optional(),
+  meta: z.string().optional(),
+  fence: z.enum(["`", "~"]).optional(),
+  fenceLength: z.number().int().min(3).optional()
+});
+var htmlBlockNodeSchema = blockNodeBase.extend({
+  type: z.literal("htmlBlock"),
+  value: z.string(),
+  htmlType: z.number().int().min(1).max(7)
+});
+var paragraphNodeSchema = blockNodeBase.extend({
+  type: z.literal("paragraph"),
+  children: z.array(z.unknown())
+});
+var linkReferenceDefinitionSchema = blockNodeBase.extend({
+  type: z.literal("linkReferenceDefinition"),
+  label: z.string(),
+  url: z.string(),
+  title: z.string().optional()
+});
+var blockquoteNodeSchema = blockNodeBase.extend({
+  type: z.literal("blockquote"),
+  children: z.array(z.unknown())
+});
+var listItemNodeSchema = blockNodeBase.extend({
+  type: z.literal("listItem"),
+  children: z.array(z.unknown()),
+  marker: z.enum(["-", "*", "+", ")", "."]),
+  spread: z.boolean(),
+  checked: z.boolean().optional()
+});
+var listNodeSchema = blockNodeBase.extend({
+  type: z.literal("list"),
+  ordered: z.boolean(),
+  start: z.number().int().min(0).optional(),
+  spread: z.boolean(),
+  marker: z.enum(["-", "*", "+", ")", "."]),
+  children: z.array(z.unknown())
+});
+var tableCellNodeSchema = blockNodeBase.extend({
+  type: z.literal("tableCell"),
+  children: z.array(z.unknown()),
+  align: z.enum(["left", "center", "right"]).optional(),
+  isHeader: z.boolean()
+});
+var tableRowNodeSchema = blockNodeBase.extend({
+  type: z.literal("tableRow"),
+  children: z.array(z.unknown()),
+  isHeader: z.boolean()
+});
+var tableNodeSchema = blockNodeBase.extend({
+  type: z.literal("table"),
+  children: z.array(z.unknown()),
+  align: z.array(z.enum(["left", "center", "right"]).nullable())
+});
+var blockNodeSchema = z.union([
+  thematicBreakNodeSchema,
+  headingNodeSchema,
+  codeBlockNodeSchema,
+  htmlBlockNodeSchema,
+  paragraphNodeSchema,
+  linkReferenceDefinitionSchema,
+  blockquoteNodeSchema,
+  listItemNodeSchema,
+  listNodeSchema,
+  tableNodeSchema
+]);
+var documentNodeSchema = z.object({
+  type: z.literal("document"),
+  children: z.array(z.unknown()),
+  references: z.record(z.string(), z.object({
+    type: z.literal("linkReferenceDefinition"),
+    label: z.string(),
+    url: z.string(),
+    title: z.string().optional(),
+    position: positionSchema.optional()
+  })).optional(),
+  position: positionSchema.optional()
+});
+var markdownDocumentSchema = z.object({
+  root: documentNodeSchema,
+  lineEnding: z.enum([`
+`, `\r
+`]),
+  source: z.string().optional()
+});
+var parseOptionsSchema = z.object({
+  positions: z.boolean().optional().default(true),
+  preserveSource: z.boolean().optional().default(false)
+});
+var generateOptionsSchema = z.object({
+  lineEnding: z.enum([`
+`, `\r
+`]).optional().default(`
+`),
+  indent: z.number().int().min(1).max(8).optional().default(3),
+  setext: z.boolean().optional().default(false),
+  fence: z.enum(["`", "~"]).optional().default("`"),
+  fenceLength: z.number().int().min(3).optional().default(3),
+  emphasis: z.enum(["*", "_"]).optional().default("*"),
+  strong: z.enum(["**", "__"]).optional().default("**"),
+  bullet: z.enum(["-", "*", "+"]).optional().default("-"),
+  orderedMarker: z.enum([")", "."]).optional().default("."),
+  thematicBreak: z.enum(["-", "*", "_"]).optional().default("-"),
+  thematicBreakLength: z.number().int().min(3).optional().default(3)
+});
+var streamOptionsSchema = parseOptionsSchema.extend({
+  chunkSize: z.number().int().positive().optional().default(65536),
+  maxBufferSize: z.number().int().positive().optional().default(DEFAULT_MAX_BUFFER_SIZE)
+});
+
+// src/parser.ts
+function parse(content, options) {
+  try {
+    const data = parseOrThrow(content, options);
+    return { success: true, data };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+function parseOrThrow(content, options) {
+  if (options !== undefined) {
+    parseOptionsSchema.parse(options);
+  }
+  const includePositions = options?.positions ?? true;
+  const preserveSource = options?.preserveSource ?? false;
+  if (!content || content.trim() === "") {
+    return {
+      root: {
+        type: "document",
+        children: [],
+        references: {}
+      },
+      lineEnding: `
+`
+    };
+  }
+  const lineEnding = detectLineEnding(content);
+  const normalized = normalizeLineEndings(content);
+  const { blocks, references } = parseBlocks(normalized, undefined, includePositions);
+  const referencesObj = {};
+  for (const [label, ref] of references) {
+    referencesObj[label] = {
+      type: "linkReferenceDefinition",
+      label,
+      url: ref.url,
+      title: ref.title
+    };
+  }
+  const document = {
+    root: {
+      type: "document",
+      children: blocks,
+      references: Object.keys(referencesObj).length > 0 ? referencesObj : undefined
+    },
+    lineEnding
+  };
+  if (preserveSource) {
+    document.source = content;
+  }
+  return document;
+}
+function parseBuffer(buffer, options) {
+  try {
+    const data = parseBufferOrThrow(buffer, options);
+    return { success: true, data };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+function parseBufferOrThrow(buffer, options) {
+  const content = decodeBuffer(buffer);
+  return parseOrThrow(content, options);
+}
+function parseToAst(content, options) {
+  return parseOrThrow(content, options).root;
+}
+function isValidMarkdown(content) {
+  const result = parse(content);
+  return result.success;
+}
+// src/generator.ts
+var DEFAULT_OPTIONS = {
+  lineEnding: `
+`,
+  indent: 3,
+  setext: false,
+  fence: "`",
+  fenceLength: 3,
+  emphasis: "*",
+  strong: "**",
+  bullet: "-",
+  orderedMarker: ".",
+  thematicBreak: "-",
+  thematicBreakLength: 3
+};
+function generate(document, options) {
+  if (options !== undefined) {
+    generateOptionsSchema.parse(options);
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const root = "root" in document ? document.root : document;
+  return generateDocument(root, opts);
+}
+function generateNode(node, options) {
+  if (options !== undefined) {
+    generateOptionsSchema.parse(options);
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (node.type === "document") {
+    return generateDocument(node, opts);
+  }
+  if (isBlockNode(node)) {
+    return generateBlock(node, opts, 0);
+  }
+  return generateInline(node, opts);
+}
+function createGenerator(options) {
+  if (options !== undefined) {
+    generateOptionsSchema.parse(options);
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const blocks = [];
+  return {
+    addNode(node) {
+      if (node.type === "document") {
+        for (const child of node.children) {
+          blocks.push(generateBlock(child, opts, 0));
+        }
+      } else if (isBlockNode(node)) {
+        blocks.push(generateBlock(node, opts, 0));
+      } else {
+        blocks.push(generateInline(node, opts));
+      }
+    },
+    toString() {
+      return blocks.join(opts.lineEnding + opts.lineEnding);
+    },
+    toStream() {
+      const blocksSnapshot = [...blocks];
+      const lineEnding = opts.lineEnding;
+      let index = 0;
+      return new ReadableStream({
+        pull(controller) {
+          if (index >= blocksSnapshot.length) {
+            controller.close();
+            return;
+          }
+          const block = blocksSnapshot[index];
+          const isLast = index === blocksSnapshot.length - 1;
+          controller.enqueue(isLast ? block : block + lineEnding + lineEnding);
+          index++;
+        }
+      });
+    }
+  };
+}
+function isBlockNode(node) {
+  return [
+    "thematicBreak",
+    "heading",
+    "codeBlock",
+    "htmlBlock",
+    "paragraph",
+    "linkReferenceDefinition",
+    "blockquote",
+    "list",
+    "listItem",
+    "table"
+  ].includes(node.type);
+}
+function generateDocument(node, opts) {
+  const blocks = node.children.map((child) => generateBlock(child, opts, 0));
+  return blocks.join(opts.lineEnding + opts.lineEnding);
+}
+function generateBlock(node, opts, depth) {
+  switch (node.type) {
+    case "thematicBreak":
+      return generateThematicBreak(node, opts);
+    case "heading":
+      return generateHeading(node, opts);
+    case "codeBlock":
+      return generateCodeBlock(node, opts);
+    case "htmlBlock":
+      return generateHtmlBlock(node);
+    case "paragraph":
+      return generateParagraph(node, opts);
+    case "blockquote":
+      return generateBlockquote(node, opts, depth);
+    case "list":
+      return generateList(node, opts, depth);
+    case "listItem":
+      return generateListItem(node, opts, depth);
+    case "table":
+      return generateTable(node, opts);
+    case "linkReferenceDefinition":
+      return generateLinkReferenceDefinition(node);
+    default:
+      return "";
+  }
+}
+function generateThematicBreak(node, opts) {
+  const char = node.marker ?? opts.thematicBreak;
+  return repeat(char, opts.thematicBreakLength);
+}
+function generateHeading(node, opts) {
+  const text = node.children.map((child) => generateInline(child, opts)).join("");
+  if (opts.setext && (node.level === 1 || node.level === 2)) {
+    const underlineChar = node.level === 1 ? "=" : "-";
+    const underline = repeat(underlineChar, Math.max(text.length, 3));
+    return text + opts.lineEnding + underline;
+  }
+  return repeat("#", node.level) + " " + text;
+}
+function generateCodeBlock(node, opts) {
+  if (node.style === "indented") {
+    const lines2 = node.value.split(`
+`);
+    return lines2.map((line) => "    " + line).join(opts.lineEnding);
+  }
+  const fence = opts.fence;
+  const fenceLength = node.fenceLength ?? opts.fenceLength;
+  const fenceStr = repeat(fence, fenceLength);
+  let infoString = node.lang ?? "";
+  if (node.meta) {
+    infoString += " " + node.meta;
+  }
+  const lines = [fenceStr + infoString, node.value, fenceStr];
+  return lines.join(opts.lineEnding);
+}
+function generateHtmlBlock(node) {
+  return node.value;
+}
+function generateParagraph(node, opts) {
+  return node.children.map((child) => generateInline(child, opts)).join("");
+}
+function generateBlockquote(node, opts, depth) {
+  const content = node.children.map((child) => generateBlock(child, opts, depth)).join(opts.lineEnding + opts.lineEnding);
+  const lines = content.split(opts.lineEnding);
+  return lines.map((line) => line ? "> " + line : ">").join(opts.lineEnding);
+}
+function generateList(node, opts, depth) {
+  const items = [];
+  let counter = node.start ?? 1;
+  for (const item of node.children) {
+    const marker = node.ordered ? `${counter}${node.marker ?? opts.orderedMarker}` : node.marker ?? opts.bullet;
+    const content = generateListItem(item, opts, depth + 1);
+    const lines = content.split(opts.lineEnding);
+    const firstLine = marker + " " + (lines[0] ?? "");
+    const indent = repeat(" ", marker.length + 1);
+    const restLines = lines.slice(1).map((line) => line ? indent + line : "");
+    items.push([firstLine, ...restLines].join(opts.lineEnding));
+    counter++;
+  }
+  const separator = node.spread ? opts.lineEnding + opts.lineEnding : opts.lineEnding;
+  return items.join(separator);
+}
+function generateListItem(node, opts, depth) {
+  let prefix = "";
+  if (node.checked !== undefined) {
+    prefix = node.checked ? "[x] " : "[ ] ";
+  }
+  const content = node.children.map((child) => generateBlock(child, opts, depth)).join(opts.lineEnding + opts.lineEnding);
+  return prefix + content;
+}
+function generateLinkReferenceDefinition(node) {
+  let result = `[${node.label}]: ${encodeUrl(node.url)}`;
+  if (node.title) {
+    result += ` "${node.title}"`;
+  }
+  return result;
+}
+function generateTable(node, opts) {
+  const rows = [];
+  const headerRow = node.children.find((r) => r.isHeader);
+  const bodyRows = node.children.filter((r) => !r.isHeader);
+  if (headerRow) {
+    rows.push(generateTableRow(headerRow, opts));
+    const delimiterCells = node.align.map((align) => {
+      if (align === "left")
+        return ":---";
+      if (align === "center")
+        return ":---:";
+      if (align === "right")
+        return "---:";
+      return "---";
+    });
+    rows.push("| " + delimiterCells.join(" | ") + " |");
+  }
+  for (const row of bodyRows) {
+    rows.push(generateTableRow(row, opts));
+  }
+  return rows.join(opts.lineEnding);
+}
+function generateTableRow(node, opts) {
+  const cells = node.children.map((cell) => generateTableCell(cell, opts));
+  return "| " + cells.join(" | ") + " |";
+}
+function generateTableCell(node, opts) {
+  return node.children.map((child) => generateInline(child, opts)).join("");
+}
+function generateInline(node, opts) {
+  switch (node.type) {
+    case "text":
+      return node.value;
+    case "codeSpan":
+      return generateCodeSpan(node.value);
+    case "emphasis":
+      return generateEmphasis(node, opts);
+    case "strong":
+      return generateStrong(node, opts);
+    case "link":
+      return generateLink(node, opts);
+    case "image":
+      return generateImage(node);
+    case "hardBreak":
+      return "  " + opts.lineEnding;
+    case "softBreak":
+      return opts.lineEnding;
+    case "htmlInline":
+      return node.value;
+    default:
+      return "";
+  }
+}
+function generateCodeSpan(value) {
+  let maxBackticks = 0;
+  let current = 0;
+  for (const char of value) {
+    if (char === "`") {
+      current++;
+      maxBackticks = Math.max(maxBackticks, current);
+    } else {
+      current = 0;
+    }
+  }
+  const backtickCount = maxBackticks + 1;
+  const backticks = "`".repeat(backtickCount);
+  const needsPadding = backtickCount > 1 || value.startsWith("`") || value.endsWith("`") || value.startsWith(" ") && value.endsWith(" ") && value.length > 0;
+  if (needsPadding) {
+    return backticks + " " + value + " " + backticks;
+  }
+  return backticks + value + backticks;
+}
+function generateEmphasis(node, opts) {
+  const marker = node.marker ?? opts.emphasis;
+  const content = node.children.map((child) => generateInline(child, opts)).join("");
+  return marker + content + marker;
+}
+function generateStrong(node, opts) {
+  const marker = node.marker ?? opts.strong;
+  const content = node.children.map((child) => generateInline(child, opts)).join("");
+  return marker + content + marker;
+}
+function generateLink(node, opts) {
+  const text = node.children.map((child) => generateInline(child, opts)).join("");
+  const url = encodeUrl(node.url);
+  if (node.title) {
+    return `[${text}](${url} "${node.title}")`;
+  }
+  return `[${text}](${url})`;
+}
+function generateImage(node) {
+  const url = encodeUrl(node.url);
+  if (node.title) {
+    return `![${node.alt}](${url} "${node.title}")`;
+  }
+  return `![${node.alt}](${url})`;
+}
+function generateHeadingString(level, text, style = "atx") {
+  if (style === "setext" && (level === 1 || level === 2)) {
+    const underlineChar = level === 1 ? "=" : "-";
+    const underline = repeat(underlineChar, Math.max(text.length, 3));
+    return text + `
+` + underline;
+  }
+  return repeat("#", level) + " " + text;
+}
+function generateLinkString(text, url, title) {
+  const encodedUrl = encodeUrl(url);
+  if (title) {
+    return `[${text}](${encodedUrl} "${title}")`;
+  }
+  return `[${text}](${encodedUrl})`;
+}
+function generateImageString(alt, url, title) {
+  const encodedUrl = encodeUrl(url);
+  if (title) {
+    return `![${alt}](${encodedUrl} "${title}")`;
+  }
+  return `![${alt}](${encodedUrl})`;
+}
+function generateCodeBlockString(code, lang, style = "fenced") {
+  if (style === "indented") {
+    return code.split(`
+`).map((line) => "    " + line).join(`
+`);
+  }
+  const fence = "```";
+  const infoString = lang ?? "";
+  return fence + infoString + `
+` + code + `
+` + fence;
+}
+function generateListString(items, ordered = false, start = 1) {
+  return items.map((item, i) => {
+    const marker = ordered ? `${start + i}.` : "-";
+    return `${marker} ${item}`;
+  }).join(`
+`);
+}
+function generateBlockquoteString(content) {
+  return content.split(`
+`).map((line) => line ? "> " + line : ">").join(`
+`);
+}
+function generateEmphasisString(text, marker = "*") {
+  return marker + text + marker;
+}
+function generateStrongString(text, marker = "**") {
+  return marker + text + marker;
+}
+function generateInlineCodeString(text) {
+  return generateCodeSpan(text);
+}
+function generateTableString(headers, rows, alignments) {
+  if (headers.length === 0) {
+    return "";
+  }
+  const columnCount = headers.length;
+  const escapeCell = (cell) => {
+    return cell.replace(/\|/g, "\\|");
+  };
+  const headerRow = "| " + headers.map((h) => escapeCell(h)).join(" | ") + " |";
+  const delimiterCells = headers.map((_, i) => {
+    const align = alignments?.[i];
+    if (align === "left")
+      return ":---";
+    if (align === "center")
+      return ":---:";
+    if (align === "right")
+      return "---:";
+    return "---";
+  });
+  const delimiterRow = "| " + delimiterCells.join(" | ") + " |";
+  const bodyRows = rows.map((row) => {
+    const paddedRow = [...row];
+    while (paddedRow.length < columnCount) {
+      paddedRow.push("");
+    }
+    const cells = paddedRow.slice(0, columnCount).map((c) => escapeCell(c));
+    return "| " + cells.join(" | ") + " |";
+  });
+  return [headerRow, delimiterRow, ...bodyRows].join(`
+`);
+}
+function generateTaskListString(items) {
+  return items.map((item) => `- [${item.checked ? "x" : " "}] ${item.text}`).join(`
+`);
+}
+function generateStrikethroughString(text) {
+  return `~~${text}~~`;
+}
+// src/html-renderer.ts
+var DEFAULT_OPTIONS2 = {
+  sanitizeHtml: true,
+  externalLinksNewTab: false,
+  classPrefix: "",
+  softBreakAsBr: false,
+  transformUrl: (url) => url,
+  elementAttributes: {}
+};
+function renderToHtml(document, options) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const root = "root" in document ? document.root : document;
+  return renderDocument(root, opts);
+}
+function renderNodeToHtml(node, options) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  if (node.type === "document") {
+    return renderDocument(node, opts);
+  }
+  if (isBlockNode2(node)) {
+    return renderBlock(node, opts);
+  }
+  return renderInline(node, opts);
+}
+function isBlockNode2(node) {
+  return [
+    "thematicBreak",
+    "heading",
+    "codeBlock",
+    "htmlBlock",
+    "paragraph",
+    "linkReferenceDefinition",
+    "blockquote",
+    "list",
+    "listItem",
+    "table"
+  ].includes(node.type);
+}
+function renderDocument(node, opts) {
+  return node.children.map((child) => renderBlock(child, opts)).join(`
+`);
+}
+function renderBlock(node, opts) {
+  switch (node.type) {
+    case "thematicBreak":
+      return renderThematicBreak(node, opts);
+    case "heading":
+      return renderHeading(node, opts);
+    case "codeBlock":
+      return renderCodeBlock(node, opts);
+    case "htmlBlock":
+      return renderHtmlBlock(node, opts);
+    case "paragraph":
+      return renderParagraph(node, opts);
+    case "blockquote":
+      return renderBlockquote(node, opts);
+    case "list":
+      return renderList(node, opts);
+    case "listItem":
+      return renderListItem(node, opts);
+    case "table":
+      return renderTable(node, opts);
+    case "linkReferenceDefinition":
+      return "";
+    default:
+      return "";
+  }
+}
+function renderThematicBreak(_node, opts) {
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}hr"` : "";
+  return `<hr${className} />`;
+}
+function renderHeading(node, opts) {
+  const tag = `h${node.level}`;
+  const content = node.children.map((child) => renderInline(child, opts)).join("");
+  const textContent = extractTextContent(node.children);
+  const headingId = generateHeadingId(textContent);
+  const idAttr = headingId ? ` id="${headingId}"` : "";
+  const attrs = buildAttributes(opts.elementAttributes.heading, opts.classPrefix, tag);
+  return `<${tag}${idAttr}${attrs}>${content}</${tag}>`;
+}
+function renderCodeBlock(node, opts) {
+  const escapedCode = encodeHtmlEntities(node.value);
+  const langClass = node.lang ? ` class="language-${encodeHtmlEntities(node.lang)}"` : "";
+  const attrs = buildAttributes(opts.elementAttributes.codeBlock, opts.classPrefix, "pre");
+  return `<pre${attrs}><code${langClass}>${escapedCode}</code></pre>`;
+}
+function renderHtmlBlock(node, opts) {
+  if (opts.sanitizeHtml) {
+    return `<div class="raw-html">${encodeHtmlEntities(node.value)}</div>`;
+  }
+  return node.value;
+}
+function renderParagraph(node, opts) {
+  const content = node.children.map((child) => renderInline(child, opts)).join("");
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}p"` : "";
+  return `<p${className}>${content}</p>`;
+}
+function renderBlockquote(node, opts) {
+  const content = node.children.map((child) => renderBlock(child, opts)).join(`
+`);
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}blockquote"` : "";
+  return `<blockquote${className}>
+${content}
+</blockquote>`;
+}
+function renderList(node, opts) {
+  const tag = node.ordered ? "ol" : "ul";
+  const startAttr = node.ordered && node.start && node.start !== 1 ? ` start="${node.start}"` : "";
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}${tag}"` : "";
+  const items = node.children.map((item) => renderListItem(item, opts)).join(`
+`);
+  return `<${tag}${startAttr}${className}>
+${items}
+</${tag}>`;
+}
+function renderListItem(node, opts) {
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}li"` : "";
+  if (node.checked !== undefined) {
+    const checkbox = `<input type="checkbox"${node.checked ? " checked" : ""} disabled />`;
+    const content2 = node.children.map((child) => renderBlock(child, opts)).join(`
+`);
+    const unwrappedContent = content2.replace(/^<p>|<\/p>$/g, "");
+    return `<li${className}>${checkbox} ${unwrappedContent}</li>`;
+  }
+  if (node.children.length === 1 && node.children[0]?.type === "paragraph") {
+    const paragraph = node.children[0];
+    const content2 = paragraph.children.map((child) => renderInline(child, opts)).join("");
+    return `<li${className}>${content2}</li>`;
+  }
+  const content = node.children.map((child) => renderBlock(child, opts)).join(`
+`);
+  return `<li${className}>
+${content}
+</li>`;
+}
+function renderTable(node, opts) {
+  const rows = node.children;
+  const headerRow = rows.find((r) => r.isHeader);
+  const bodyRows = rows.filter((r) => !r.isHeader);
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}table"` : "";
+  let html = `<table${className}>`;
+  if (headerRow) {
+    html += `
+<thead>
+` + renderTableRow(headerRow, opts) + `
+</thead>`;
+  }
+  if (bodyRows.length > 0) {
+    html += `
+<tbody>
+` + bodyRows.map((r) => renderTableRow(r, opts)).join(`
+`) + `
+</tbody>`;
+  }
+  html += `
+</table>`;
+  return html;
+}
+function renderTableRow(node, opts) {
+  const cells = node.children.map((cell) => renderTableCell(cell, opts)).join("");
+  return `<tr>${cells}</tr>`;
+}
+function renderTableCell(node, opts) {
+  const tag = node.isHeader ? "th" : "td";
+  const alignStyle = node.align ? ` style="text-align: ${node.align}"` : "";
+  const content = node.children.map((child) => renderInline(child, opts)).join("");
+  return `<${tag}${alignStyle}>${content}</${tag}>`;
+}
+function renderInline(node, opts) {
+  switch (node.type) {
+    case "text":
+      return renderText(node);
+    case "codeSpan":
+      return renderCodeSpan(node, opts);
+    case "emphasis":
+      return renderEmphasis(node, opts);
+    case "strong":
+      return renderStrong(node, opts);
+    case "link":
+      return renderLink(node, opts);
+    case "image":
+      return renderImage(node, opts);
+    case "hardBreak":
+      return renderHardBreak();
+    case "softBreak":
+      return renderSoftBreak(opts);
+    case "htmlInline":
+      return renderHtmlInline(node, opts);
+    default:
+      return "";
+  }
+}
+function renderText(node) {
+  return encodeHtmlEntities(node.value);
+}
+function renderCodeSpan(node, opts) {
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}code"` : "";
+  return `<code${className}>${encodeHtmlEntities(node.value)}</code>`;
+}
+function renderEmphasis(node, opts) {
+  const content = node.children.map((child) => renderInline(child, opts)).join("");
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}em"` : "";
+  return `<em${className}>${content}</em>`;
+}
+function renderStrong(node, opts) {
+  const content = node.children.map((child) => renderInline(child, opts)).join("");
+  const className = opts.classPrefix ? ` class="${opts.classPrefix}strong"` : "";
+  return `<strong${className}>${content}</strong>`;
+}
+function renderLink(node, opts) {
+  const content = node.children.map((child) => renderInline(child, opts)).join("");
+  const url = encodeHtmlEntities(opts.transformUrl(node.url, "link"));
+  const title = node.title ? ` title="${encodeHtmlEntities(node.title)}"` : "";
+  let extraAttrs = "";
+  if (opts.externalLinksNewTab && isExternalUrl(node.url)) {
+    extraAttrs = ' target="_blank" rel="noopener noreferrer"';
+  }
+  const customAttrs = buildAttributes(opts.elementAttributes.link, opts.classPrefix, "a");
+  return `<a href="${url}"${title}${extraAttrs}${customAttrs}>${content}</a>`;
+}
+function renderImage(node, opts) {
+  const url = encodeHtmlEntities(opts.transformUrl(node.url, "image"));
+  const alt = encodeHtmlEntities(node.alt);
+  const title = node.title ? ` title="${encodeHtmlEntities(node.title)}"` : "";
+  const attrs = buildAttributes(opts.elementAttributes.image, opts.classPrefix, "img");
+  return `<img src="${url}" alt="${alt}"${title}${attrs} />`;
+}
+function renderHardBreak() {
+  return "<br />";
+}
+function renderSoftBreak(opts) {
+  return opts.softBreakAsBr ? "<br />" : `
+`;
+}
+function renderHtmlInline(node, opts) {
+  if (opts.sanitizeHtml) {
+    return encodeHtmlEntities(node.value);
+  }
+  return node.value;
+}
+function isExternalUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function generateHeadingId(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").slice(0, 50);
+}
+function extractTextContent(nodes) {
+  return nodes.map((node) => {
+    if (node.type === "text")
+      return node.value;
+    if (node.type === "codeSpan")
+      return node.value;
+    if ("children" in node && Array.isArray(node.children)) {
+      return extractTextContent(node.children);
+    }
+    return "";
+  }).join("");
+}
+function buildAttributes(customAttrs, classPrefix, elementName) {
+  const attrs = [];
+  if (classPrefix) {
+    attrs.push(`class="${classPrefix}${elementName}"`);
+  }
+  if (customAttrs) {
+    for (const [key, value] of Object.entries(customAttrs)) {
+      attrs.push(`${key}="${encodeHtmlEntities(value)}"`);
+    }
+  }
+  return attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+}
+// src/html-parser.ts
+var SELF_CLOSING_TAGS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var BLOCK_TAGS = new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "dd",
+  "details",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "ul"
+]);
+function parseHtml(html) {
+  let pos = 0;
+  function parseNodes() {
+    const result = [];
+    while (pos < html.length) {
+      if (html.startsWith("</", pos)) {
+        break;
+      }
+      if (html.startsWith("<!--", pos)) {
+        const endPos = html.indexOf("-->", pos + 4);
+        if (endPos !== -1) {
+          pos = endPos + 3;
+          continue;
+        }
+      }
+      if (html[pos] === "<") {
+        const element = parseElement();
+        if (element) {
+          result.push(element);
+          continue;
+        }
+      }
+      const text = parseText();
+      if (text) {
+        result.push(text);
+      }
+    }
+    return result;
+  }
+  function parseElement() {
+    if (html[pos] !== "<")
+      return null;
+    const tagStart = pos + 1;
+    let tagEnd = tagStart;
+    while (tagEnd < html.length && !/[\s/>]/.test(html[tagEnd])) {
+      tagEnd++;
+    }
+    const tag = html.slice(tagStart, tagEnd).toLowerCase();
+    if (!tag || tag.startsWith("!"))
+      return null;
+    const attributes = {};
+    let attrPos = tagEnd;
+    while (attrPos < html.length) {
+      while (attrPos < html.length && /\s/.test(html[attrPos])) {
+        attrPos++;
+      }
+      if (html[attrPos] === ">" || html.startsWith("/>", attrPos)) {
+        break;
+      }
+      let attrNameEnd = attrPos;
+      while (attrNameEnd < html.length && !/[\s=/>]/.test(html[attrNameEnd])) {
+        attrNameEnd++;
+      }
+      const attrName = html.slice(attrPos, attrNameEnd).toLowerCase();
+      attrPos = attrNameEnd;
+      while (attrPos < html.length && /\s/.test(html[attrPos])) {
+        attrPos++;
+      }
+      if (html[attrPos] === "=") {
+        attrPos++;
+        while (attrPos < html.length && /\s/.test(html[attrPos])) {
+          attrPos++;
+        }
+        let value;
+        const quote = html[attrPos];
+        if (quote === '"' || quote === "'") {
+          attrPos++;
+          const valueEnd = html.indexOf(quote, attrPos);
+          if (valueEnd !== -1) {
+            value = html.slice(attrPos, valueEnd);
+            attrPos = valueEnd + 1;
+          } else {
+            value = "";
+          }
+        } else {
+          let valueEnd = attrPos;
+          while (valueEnd < html.length && !/[\s>]/.test(html[valueEnd])) {
+            valueEnd++;
+          }
+          value = html.slice(attrPos, valueEnd);
+          attrPos = valueEnd;
+        }
+        attributes[attrName] = decodeHtmlEntities2(value);
+      } else if (attrName) {
+        attributes[attrName] = "";
+      }
+    }
+    const selfClosing = html.startsWith("/>", attrPos) || SELF_CLOSING_TAGS.has(tag);
+    if (html.startsWith("/>", attrPos)) {
+      pos = attrPos + 2;
+    } else {
+      const closePos = html.indexOf(">", attrPos);
+      if (closePos === -1)
+        return null;
+      pos = closePos + 1;
+    }
+    if (selfClosing) {
+      return { type: "element", tag, attributes };
+    }
+    const children = parseNodes();
+    const closingTag = `</${tag}>`;
+    const closingPos = html.toLowerCase().indexOf(closingTag.toLowerCase(), pos);
+    if (closingPos !== -1) {
+      pos = closingPos + closingTag.length;
+    }
+    return { type: "element", tag, attributes, children };
+  }
+  function parseText() {
+    const start = pos;
+    while (pos < html.length && html[pos] !== "<") {
+      pos++;
+    }
+    const content = html.slice(start, pos);
+    if (!content)
+      return null;
+    return { type: "text", content: decodeHtmlEntities2(content) };
+  }
+  return parseNodes();
+}
+function decodeHtmlEntities2(text) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&apos;": "'",
+    "&nbsp;": " ",
+    "&ndash;": "–",
+    "&mdash;": "—",
+    "&lsquo;": "‘",
+    "&rsquo;": "’",
+    "&ldquo;": "“",
+    "&rdquo;": "”",
+    "&copy;": "©",
+    "&reg;": "®",
+    "&trade;": "™",
+    "&hellip;": "…"
+  };
+  let result = text;
+  for (const [entity, char] of Object.entries(entities)) {
+    result = result.split(entity).join(char);
+  }
+  result = result.replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number.parseInt(code, 10)));
+  result = result.replace(/&#x([0-9a-fA-F]+);/g, (_, code) => String.fromCharCode(Number.parseInt(code, 16)));
+  return result;
+}
+function htmlAstToMarkdownAst(nodes, options = {}) {
+  const blocks = convertNodesToBlocks(nodes, options);
+  return {
+    type: "document",
+    children: blocks
+  };
+}
+function convertNodesToBlocks(nodes, options) {
+  const blocks = [];
+  for (const node of nodes) {
+    const converted = convertNodeToBlocks(node, options);
+    blocks.push(...converted);
+  }
+  return blocks;
+}
+function convertNodeToBlocks(node, options) {
+  if (node.type === "text") {
+    const trimmed = options.preserveWhitespace ? node.content || "" : (node.content || "").trim();
+    if (!trimmed)
+      return [];
+    const paragraph = {
+      type: "paragraph",
+      children: [{ type: "text", value: trimmed }]
+    };
+    return [paragraph];
+  }
+  if (node.type === "comment") {
+    return [];
+  }
+  const tag = node.tag || "";
+  const children = node.children || [];
+  const attributes = node.attributes || {};
+  if (/^h([1-6])$/.test(tag)) {
+    const level = Number.parseInt(tag[1], 10);
+    const heading = {
+      type: "heading",
+      level,
+      style: options.headingStyle || "atx",
+      children: convertNodesToInline(children, options)
+    };
+    return [heading];
+  }
+  if (tag === "p") {
+    const inlineChildren2 = convertNodesToInline(children, options);
+    if (inlineChildren2.length === 0)
+      return [];
+    const paragraph = {
+      type: "paragraph",
+      children: inlineChildren2
+    };
+    return [paragraph];
+  }
+  if (tag === "hr") {
+    const hr = {
+      type: "thematicBreak",
+      marker: "-"
+    };
+    return [hr];
+  }
+  if (tag === "blockquote") {
+    const blockquote = {
+      type: "blockquote",
+      children: convertNodesToBlocks(children, options)
+    };
+    return [blockquote];
+  }
+  if (tag === "ul") {
+    const list = {
+      type: "list",
+      ordered: false,
+      spread: false,
+      marker: options.bulletMarker || "-",
+      children: convertListItems(children, options)
+    };
+    return [list];
+  }
+  if (tag === "ol") {
+    const start = attributes.start ? Number.parseInt(attributes.start, 10) : 1;
+    const list = {
+      type: "list",
+      ordered: true,
+      start,
+      spread: false,
+      marker: ".",
+      children: convertListItems(children, options)
+    };
+    return [list];
+  }
+  if (tag === "pre") {
+    const codeChild = children.find((c) => c.type === "element" && c.tag === "code");
+    const content = codeChild ? extractTextContent2(codeChild.children || []) : extractTextContent2(children);
+    const codeAttrs = codeChild?.attributes || {};
+    const className = codeAttrs.class || "";
+    const langMatch = className.match(/language-(\w+)/);
+    const lang = langMatch ? langMatch[1] : undefined;
+    const codeBlock = {
+      type: "codeBlock",
+      style: options.codeBlockStyle || "fenced",
+      fence: options.fence || "`",
+      fenceLength: 3,
+      lang,
+      value: content.trim()
+    };
+    return [codeBlock];
+  }
+  if (tag === "table") {
+    const table = convertTable(children, options);
+    if (table)
+      return [table];
+    return [];
+  }
+  if ([
+    "div",
+    "section",
+    "article",
+    "main",
+    "aside",
+    "nav",
+    "header",
+    "footer"
+  ].includes(tag)) {
+    return convertNodesToBlocks(children, options);
+  }
+  if (tag === "figure") {
+    const blocks = [];
+    for (const child of children) {
+      if (child.type === "element") {
+        if (child.tag === "img") {
+          const imgBlocks = convertNodeToBlocks(child, options);
+          blocks.push(...imgBlocks);
+        } else if (child.tag === "figcaption") {
+          const caption = extractTextContent2(child.children || []).trim();
+          if (caption) {
+            const paragraph = {
+              type: "paragraph",
+              children: [
+                {
+                  type: "emphasis",
+                  marker: "*",
+                  children: [{ type: "text", value: caption }]
+                }
+              ]
+            };
+            blocks.push(paragraph);
+          }
+        }
+      }
+    }
+    return blocks;
+  }
+  if (tag === "img") {
+    const src = attributes.src || "";
+    const alt = attributes.alt || "";
+    const title = attributes.title;
+    const image = {
+      type: "image",
+      url: src,
+      alt,
+      title
+    };
+    const paragraph = {
+      type: "paragraph",
+      children: [image]
+    };
+    return [paragraph];
+  }
+  const inlineChildren = convertNodesToInline(children, options);
+  if (inlineChildren.length > 0) {
+    const hasContent = inlineChildren.some((c) => c.type !== "text" || c.type === "text" && c.value.trim());
+    if (hasContent) {
+      const paragraph = {
+        type: "paragraph",
+        children: inlineChildren
+      };
+      return [paragraph];
+    }
+  }
+  return [];
+}
+function convertListItems(nodes, options) {
+  const items = [];
+  for (const node of nodes) {
+    if (node.type === "element" && node.tag === "li") {
+      const children = node.children || [];
+      const hasBlockChildren = children.some((c) => c.type === "element" && c.tag && BLOCK_TAGS.has(c.tag) && c.tag !== "li");
+      let itemChildren;
+      if (hasBlockChildren) {
+        itemChildren = convertNodesToBlocks(children, options);
+      } else {
+        const inlineContent = convertNodesToInline(children, options);
+        if (inlineContent.length > 0) {
+          itemChildren = [
+            {
+              type: "paragraph",
+              children: inlineContent
+            }
+          ];
+        } else {
+          itemChildren = [];
+        }
+      }
+      const checkbox = children.find((c) => c.type === "element" && c.tag === "input" && c.attributes?.type === "checkbox");
+      const item = {
+        type: "listItem",
+        marker: "-",
+        spread: false,
+        children: itemChildren
+      };
+      if (checkbox) {
+        item.checked = checkbox.attributes?.checked !== undefined;
+      }
+      items.push(item);
+    }
+  }
+  return items;
+}
+function convertNodesToInline(nodes, options) {
+  const result = [];
+  for (const node of nodes) {
+    const converted = convertNodeToInline(node, options);
+    result.push(...converted);
+  }
+  return result;
+}
+function convertNodeToInline(node, options) {
+  if (node.type === "text") {
+    const content = options.preserveWhitespace ? node.content || "" : normalizeWhitespace(node.content || "");
+    if (!content)
+      return [];
+    return [{ type: "text", value: content }];
+  }
+  if (node.type === "comment") {
+    return [];
+  }
+  const tag = node.tag || "";
+  const children = node.children || [];
+  const attributes = node.attributes || {};
+  if (tag === "strong" || tag === "b") {
+    const strong = {
+      type: "strong",
+      marker: options.strongMarker || "**",
+      children: convertNodesToInline(children, options)
+    };
+    return [strong];
+  }
+  if (tag === "em" || tag === "i") {
+    const emphasis = {
+      type: "emphasis",
+      marker: options.emphasisMarker || "*",
+      children: convertNodesToInline(children, options)
+    };
+    return [emphasis];
+  }
+  if (tag === "s" || tag === "del" || tag === "strike") {
+    const content = extractTextContent2(children);
+    return [{ type: "text", value: `~~${content}~~` }];
+  }
+  if (tag === "code") {
+    const content = extractTextContent2(children);
+    const codeSpan = {
+      type: "codeSpan",
+      value: content
+    };
+    return [codeSpan];
+  }
+  if (tag === "a") {
+    const href = attributes.href || "";
+    const title = attributes.title;
+    const link = {
+      type: "link",
+      url: href,
+      title,
+      children: convertNodesToInline(children, options)
+    };
+    return [link];
+  }
+  if (tag === "img") {
+    const src = attributes.src || "";
+    const alt = attributes.alt || "";
+    const title = attributes.title;
+    const image = {
+      type: "image",
+      url: src,
+      alt,
+      title
+    };
+    return [image];
+  }
+  if (tag === "br") {
+    const hardBreak = {
+      type: "hardBreak"
+    };
+    return [hardBreak];
+  }
+  if (tag === "sub" || tag === "sup") {
+    const content = extractTextContent2(children);
+    return [{ type: "text", value: content }];
+  }
+  if (["span", "small", "mark", "u", "abbr", "cite", "q", "time"].includes(tag)) {
+    return convertNodesToInline(children, options);
+  }
+  const textContent = extractTextContent2([node]);
+  if (textContent.trim()) {
+    return [{ type: "text", value: normalizeWhitespace(textContent) }];
+  }
+  return [];
+}
+function convertTable(nodes, options) {
+  const rows = [];
+  let headerRow = null;
+  let alignments = [];
+  for (const node of nodes) {
+    if (node.type !== "element")
+      continue;
+    if (node.tag === "thead") {
+      const theadRows = extractTableRows(node.children || [], true, options);
+      if (theadRows.length > 0) {
+        headerRow = theadRows[0];
+        alignments = extractAlignments(node.children || []);
+      }
+    } else if (node.tag === "tbody") {
+      const tbodyRows = extractTableRows(node.children || [], false, options);
+      rows.push(...tbodyRows);
+    } else if (node.tag === "tr") {
+      if (!headerRow) {
+        headerRow = convertTableRow(node, true, options);
+        alignments = extractRowAlignments(node);
+      } else {
+        rows.push(convertTableRow(node, false, options));
+      }
+    }
+  }
+  if (!headerRow && rows.length === 0)
+    return null;
+  if (!headerRow && rows.length > 0) {
+    headerRow = rows.shift();
+  }
+  const allRows = headerRow ? [headerRow, ...rows] : rows;
+  if (allRows.length === 0)
+    return null;
+  for (const row of allRows) {
+    for (let i = 0;i < row.children.length; i++) {
+      const cell = row.children[i];
+      if (cell && alignments[i]) {
+        cell.align = alignments[i] ?? undefined;
+      }
+    }
+  }
+  return {
+    type: "table",
+    align: alignments,
+    children: allRows
+  };
+}
+function extractTableRows(nodes, isHeader, options) {
+  const rows = [];
+  for (const node of nodes) {
+    if (node.type === "element" && node.tag === "tr") {
+      rows.push(convertTableRow(node, isHeader, options));
+    }
+  }
+  return rows;
+}
+function convertTableRow(node, isHeader, options) {
+  const cells = [];
+  for (const child of node.children || []) {
+    if (child.type === "element" && (child.tag === "td" || child.tag === "th")) {
+      const cell = {
+        type: "tableCell",
+        isHeader: child.tag === "th" || isHeader,
+        children: convertNodesToInline(child.children || [], options)
+      };
+      const align = child.attributes?.align?.toLowerCase();
+      const style = child.attributes?.style || "";
+      const styleAlign = style.match(/text-align:\s*(left|center|right)/i);
+      if (align === "left" || align === "center" || align === "right") {
+        cell.align = align;
+      } else if (styleAlign) {
+        cell.align = styleAlign[1].toLowerCase();
+      }
+      cells.push(cell);
+    }
+  }
+  return {
+    type: "tableRow",
+    isHeader,
+    children: cells
+  };
+}
+function extractAlignments(nodes) {
+  for (const node of nodes) {
+    if (node.type === "element" && node.tag === "tr") {
+      return extractRowAlignments(node);
+    }
+  }
+  return [];
+}
+function extractRowAlignments(row) {
+  const alignments = [];
+  for (const child of row.children || []) {
+    if (child.type === "element" && (child.tag === "td" || child.tag === "th")) {
+      const align = child.attributes?.align?.toLowerCase();
+      const style = child.attributes?.style || "";
+      const styleAlign = style.match(/text-align:\s*(left|center|right)/i);
+      if (align === "left" || align === "center" || align === "right") {
+        alignments.push(align);
+      } else if (styleAlign) {
+        alignments.push(styleAlign[1].toLowerCase());
+      } else {
+        alignments.push(null);
+      }
+    }
+  }
+  return alignments;
+}
+function extractTextContent2(nodes) {
+  let text = "";
+  for (const node of nodes) {
+    if (node.type === "text") {
+      text += node.content || "";
+    } else if (node.type === "element" && node.children) {
+      text += extractTextContent2(node.children);
+    }
+  }
+  return text;
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ");
+}
+function htmlToMarkdown(html, options = {}) {
+  const cleanHtml = html.replace(/<!DOCTYPE[^>]*>/gi, "").replace(/<\/?html[^>]*>/gi, "").replace(/<head[\s\S]*?<\/head>/gi, "").replace(/<\/?body[^>]*>/gi, "").trim();
+  if (!cleanHtml)
+    return "";
+  const htmlAst = parseHtml(cleanHtml);
+  const markdownAst = htmlAstToMarkdownAst(htmlAst, options);
+  const generateOptions = {};
+  if (options.fence !== undefined)
+    generateOptions.fence = options.fence;
+  if (options.emphasisMarker !== undefined)
+    generateOptions.emphasis = options.emphasisMarker;
+  if (options.strongMarker !== undefined)
+    generateOptions.strong = options.strongMarker;
+  if (options.bulletMarker !== undefined)
+    generateOptions.bullet = options.bulletMarker;
+  if (options.headingStyle === "setext")
+    generateOptions.setext = true;
+  return generate(markdownAst, generateOptions);
+}
+// src/stream.ts
+function createStreamingParserState(options) {
+  return {
+    buffer: "",
+    lineBuffer: [],
+    references: new Map,
+    includePositions: options?.positions ?? true,
+    maxBufferSize: options?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE
+  };
+}
+async function* parseStream(input, options) {
+  if (options !== undefined) {
+    streamOptionsSchema.parse(options);
+  }
+  const state = createStreamingParserState(options);
+  let iterable;
+  if (input instanceof ReadableStream) {
+    const reader = input.getReader();
+    const decoder = new TextDecoder;
+    iterable = {
+      async* [Symbol.asyncIterator]() {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          yield decoder.decode(value, { stream: true });
+        }
+        const final = decoder.decode();
+        if (final)
+          yield final;
+      }
+    };
+  } else {
+    iterable = input;
+  }
+  for await (const chunk of iterable) {
+    yield* processStreamChunk(chunk, state);
+  }
+  yield* flushStreamBuffer(state);
+  const document = buildDocument(state);
+  yield { type: "complete", document };
+}
+function* processStreamChunk(chunk, state) {
+  state.buffer += chunk;
+  if (state.buffer.length > state.maxBufferSize) {
+    yield {
+      type: "error",
+      error: `Buffer size exceeded maximum of ${state.maxBufferSize} bytes`
+    };
+    return;
+  }
+  const normalized = normalizeLineEndings(state.buffer);
+  const lines = normalized.split(`
+`);
+  state.buffer = lines.pop() ?? "";
+  state.lineBuffer.push(...lines);
+  yield* processLineBuffer(state);
+}
+function* processLineBuffer(state) {
+  while (state.lineBuffer.length > 0) {
+    const { block, consumedLines } = extractNextBlock(state);
+    if (block) {
+      yield { type: "block", data: block };
+      state.lineBuffer.splice(0, consumedLines);
+    } else {
+      break;
+    }
+  }
+}
+function extractNextBlock(state) {
+  if (state.lineBuffer.length === 0) {
+    return { block: null, consumedLines: 0 };
+  }
+  let endIndex = -1;
+  let blankCount = 0;
+  let inFencedCode = false;
+  let fenceChar = "";
+  let fenceLength = 0;
+  let closingFenceRegex = null;
+  for (let i = 0;i < state.lineBuffer.length; i++) {
+    const line = state.lineBuffer[i] ?? "";
+    const trimmedLine = line.trimStart();
+    const fenceMatch = /^(`{3,}|~{3,})/.exec(trimmedLine);
+    if (fenceMatch) {
+      if (!inFencedCode) {
+        inFencedCode = true;
+        fenceChar = fenceMatch[1]?.[0] ?? "`";
+        fenceLength = fenceMatch[1]?.length ?? 3;
+        closingFenceRegex = new RegExp(`^${fenceChar}{${fenceLength},}\\s*$`);
+      } else if (closingFenceRegex?.test(trimmedLine)) {
+        inFencedCode = false;
+        closingFenceRegex = null;
+        endIndex = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (inFencedCode)
+      continue;
+    if (trimmedLine === "") {
+      blankCount++;
+      if (blankCount >= 2 && i > 0) {
+        endIndex = i;
+        break;
+      }
+    } else {
+      blankCount = 0;
+    }
+  }
+  if (inFencedCode || endIndex < 0) {
+    if (state.lineBuffer.length > 100) {
+      endIndex = Math.min(50, state.lineBuffer.length);
+    } else {
+      return { block: null, consumedLines: 0 };
+    }
+  }
+  const content = state.lineBuffer.slice(0, endIndex).join(`
+`);
+  const context = createBlockContext();
+  context.references = state.references;
+  const { blocks, references } = parseBlocks(content, context, state.includePositions);
+  for (const [key, value] of references) {
+    state.references.set(key, value);
+  }
+  if (blocks.length > 0) {
+    return { block: blocks[0] ?? null, consumedLines: endIndex };
+  }
+  return { block: null, consumedLines: endIndex };
+}
+function* flushStreamBuffer(state) {
+  if (state.buffer.trim()) {
+    state.lineBuffer.push(state.buffer);
+  }
+  state.buffer = "";
+  if (state.lineBuffer.length > 0) {
+    const content = state.lineBuffer.join(`
+`);
+    const context = createBlockContext();
+    context.references = state.references;
+    const { blocks, references } = parseBlocks(content, context, state.includePositions);
+    for (const [key, value] of references) {
+      state.references.set(key, value);
+    }
+    for (const block of blocks) {
+      yield { type: "block", data: block };
+    }
+  }
+}
+function buildDocument(state) {
+  const referencesObj = {};
+  for (const [label, ref] of state.references) {
+    referencesObj[label] = {
+      type: "linkReferenceDefinition",
+      label,
+      url: ref.url,
+      title: ref.title
+    };
+  }
+  return {
+    root: {
+      type: "document",
+      children: [],
+      references: Object.keys(referencesObj).length > 0 ? referencesObj : undefined
+    },
+    lineEnding: `
+`
+  };
+}
+async function parseStreamToDocument(input, options) {
+  const blocks = [];
+  let document = null;
+  for await (const event of parseStream(input, options)) {
+    switch (event.type) {
+      case "block":
+        blocks.push(event.data);
+        break;
+      case "complete":
+        document = event.document;
+        break;
+      case "error":
+        throw new Error(event.error);
+    }
+  }
+  if (!document) {
+    throw new Error("Stream ended without completion event");
+  }
+  document.root.children = blocks;
+  return document;
+}
+async function* parseBufferStream(buffer, options) {
+  const content = decodeBuffer(buffer);
+  const chunkSize = options?.chunkSize ?? 65536;
+  async function* chunkGenerator() {
+    for (let i = 0;i < content.length; i += chunkSize) {
+      yield content.slice(i, i + chunkSize);
+    }
+  }
+  yield* parseStream(chunkGenerator(), options);
+}
+async function* parseBatchStream(files, options) {
+  let errorCount = 0;
+  for (let i = 0;i < files.length; i++) {
+    const file = files[i];
+    if (!file)
+      continue;
+    const filename = file.filename;
+    const content = file.content;
+    yield { type: "file_start", fileIndex: i, filename };
+    try {
+      const blocks = [];
+      async function* chunkGenerator() {
+        const chunkSize = options?.chunkSize ?? 65536;
+        for (let j = 0;j < content.length; j += chunkSize) {
+          yield content.slice(j, j + chunkSize);
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+      }
+      for await (const event of parseStream(chunkGenerator(), options)) {
+        switch (event.type) {
+          case "block":
+            yield { type: "block", fileIndex: i, data: event.data };
+            blocks.push(event.data);
+            break;
+          case "complete": {
+            const doc = {
+              ...event.document,
+              root: {
+                ...event.document.root,
+                children: blocks
+              }
+            };
+            yield {
+              type: "file_complete",
+              fileIndex: i,
+              filename,
+              document: doc
+            };
+            break;
+          }
+          case "error":
+            throw new Error(event.error);
+        }
+      }
+    } catch (err) {
+      errorCount++;
+      yield {
+        type: "file_error",
+        fileIndex: i,
+        filename,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  yield {
+    type: "batch_complete",
+    totalFiles: files.length,
+    errorCount
+  };
+}
+async function parseBatchStreamToArray(files, options) {
+  const results = files.map((file, index) => ({
+    fileIndex: index,
+    filename: file.filename
+  }));
+  for await (const event of parseBatchStream(files, options)) {
+    switch (event.type) {
+      case "file_complete": {
+        const result = results[event.fileIndex];
+        if (result) {
+          result.document = event.document;
+        }
+        break;
+      }
+      case "file_error": {
+        const result = results[event.fileIndex];
+        if (result) {
+          result.error = event.error;
+        }
+        break;
+      }
+    }
+  }
+  return results;
+}
+export {
+  thematicBreakNodeSchema,
+  textNodeSchema,
+  tableRowNodeSchema,
+  tableNodeSchema,
+  tableCellNodeSchema,
+  strongNodeSchema,
+  streamOptionsSchema,
+  softBreakNodeSchema,
+  renderToHtml,
+  renderNodeToHtml,
+  positionSchema,
+  parseToAst,
+  parseStreamToDocument,
+  parseStream,
+  parseOrThrow,
+  parseOptionsSchema,
+  parseHtml,
+  parseBufferStream,
+  parseBufferOrThrow,
+  parseBuffer,
+  parseBatchStreamToArray,
+  parseBatchStream,
+  parse,
+  paragraphNodeSchema,
+  normalizeMarkdownEmphasis,
+  normalizeLineEndings,
+  normalizeEscapedNewlines,
+  markdownDocumentSchema,
+  listNodeSchema,
+  listItemNodeSchema,
+  linkReferenceDefinitionSchema,
+  linkNodeSchema,
+  isValidMarkdown,
+  inlineNodeSchema,
+  imageNodeSchema,
+  htmlToMarkdown,
+  htmlInlineNodeSchema,
+  htmlBlockNodeSchema,
+  htmlAstToMarkdownAst,
+  headingNodeSchema,
+  hardBreakNodeSchema,
+  generateTaskListString,
+  generateTableString,
+  generateStrongString,
+  generateStrikethroughString,
+  generateOptionsSchema,
+  generateNode,
+  generateListString,
+  generateLinkString,
+  generateInlineCodeString,
+  generateImageString,
+  generateHeadingString,
+  generateEmphasisString,
+  generateCodeBlockString,
+  generateBlockquoteString,
+  generate,
+  emphasisNodeSchema,
+  documentNodeSchema,
+  createGenerator,
+  codeSpanNodeSchema,
+  codeBlockNodeSchema,
+  blockquoteNodeSchema,
+  blockNodeSchema,
+  DEFAULT_MAX_BUFFER_SIZE
+};