@pre-markdown/parser 0.2.0

package/dist/index.js

@@ -0,0 +1,2013 @@
+// src/block/parser.ts
+import {
+  createDocument,
+  createHeading,
+  createParagraph,
+  createBlockquote,
+  createList,
+  createListItem,
+  createCodeBlock,
+  createThematicBreak,
+  createHtmlBlock,
+  createTable,
+  createTableRow,
+  createTableCell,
+  createFootnoteDefinition,
+  createMathBlock,
+  createContainer,
+  createDetails,
+  createTOC
+} from "@pre-markdown/core";
+
+// src/inline/parser.ts
+import {
+  createText,
+  createEmphasis,
+  createStrong,
+  createStrikethrough,
+  createInlineCode,
+  createLink,
+  createImage,
+  createHtmlInline,
+  createBreak,
+  createSoftBreak,
+  createMathInline,
+  createHighlight,
+  createSuperscript,
+  createSubscript,
+  createAutolink,
+  createFootnoteReference,
+  createFontColor,
+  createFontSize,
+  createFontBgColor,
+  createRuby,
+  createEmoji,
+  createAudio,
+  createVideo,
+  createUnderline
+} from "@pre-markdown/core";
+var RE_ESCAPE = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
+var RE_FOOTNOTE_REF = /\[\^([^\]]+)\]/y;
+var RE_AUTOLINK_URI = /<([a-zA-Z][a-zA-Z0-9+.\-]{1,31}:[^\s<>]*)>/y;
+var RE_AUTOLINK_EMAIL = /<([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])?)*)>/y;
+var RE_HTML_INLINE_OPEN = /<[a-zA-Z][a-zA-Z0-9-]*(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^\s"'=<>`]+|'[^']*'|"[^"]*"))?)*\s*\/?>/y;
+var RE_HTML_INLINE_CLOSE = /<\/[a-zA-Z][a-zA-Z0-9-]*\s*>/y;
+var RE_HTML_COMMENT = /<!--(?!>)(?!->)[\s\S]*?-->/y;
+var RE_HTML_PI = /<\?[\s\S]*?\?>/y;
+var RE_HTML_DECL = /<![A-Z]+[^>]*>/y;
+var RE_HTML_CDATA = /<!\[CDATA\[[\s\S]*?\]\]>/y;
+var RE_CHERRY_COLOR = /!!(#[0-9a-zA-Z]{3,6}|[a-z]{3,20})\s([\w\W]+?)!!/y;
+var RE_CHERRY_SIZE = /!([0-9]{1,2})\s([\w\W]*?)!/y;
+var RE_CHERRY_BGCOLOR = /!!!(#[0-9a-zA-Z]{3,6}|[a-z]{3,10})\s([\w\W]+?)!!!/y;
+var RE_FONT_COLOR = /\{color:([^}]+)\}/y;
+var RE_FONT_SIZE = /\{size:([^}]+)\}/y;
+var RE_FONT_BGCOLOR = /\{bgcolor:([^}]+)\}/y;
+var RE_EMOJI = /:([a-zA-Z0-9_+-]+):/y;
+var RE_AUDIO = /!audio\[([^\]]*)\]\(([^)]+)\)/y;
+var RE_VIDEO = /!video\[([^\]]*)\]\(([^)]+)\)/y;
+var RE_ENTITY = /&(?:#[xX]([0-9a-fA-F]{1,6})|#([0-9]{1,7})|([a-zA-Z][a-zA-Z0-9]{1,31}));/y;
+var HTML_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0",
+  copy: "\xA9",
+  reg: "\xAE",
+  AElig: "\xC6",
+  Dcaron: "\u010E",
+  frac34: "\xBE",
+  HilbertSpace: "\u210B",
+  DifferentialD: "\u2146",
+  ClockwiseContourIntegral: "\u2232",
+  ngE: "\u2267\u0338",
+  ouml: "\xF6",
+  uuml: "\xFC",
+  auml: "\xE4",
+  szlig: "\xDF",
+  ntilde: "\xF1",
+  eacute: "\xE9",
+  Ouml: "\xD6",
+  Uuml: "\xDC",
+  Auml: "\xC4",
+  mdash: "\u2014",
+  ndash: "\u2013",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bull: "\u2022",
+  hellip: "\u2026",
+  trade: "\u2122",
+  larr: "\u2190",
+  rarr: "\u2192",
+  uarr: "\u2191",
+  darr: "\u2193",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  euro: "\u20AC",
+  pound: "\xA3",
+  yen: "\xA5",
+  cent: "\xA2",
+  times: "\xD7",
+  divide: "\xF7",
+  plusmn: "\xB1",
+  infin: "\u221E",
+  ne: "\u2260",
+  le: "\u2264",
+  ge: "\u2265",
+  deg: "\xB0",
+  micro: "\xB5",
+  para: "\xB6",
+  sect: "\xA7",
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  pi: "\u03C0",
+  sigma: "\u03C3",
+  omega: "\u03C9",
+  hearts: "\u2665",
+  diams: "\u2666",
+  clubs: "\u2663",
+  spades: "\u2660",
+  iexcl: "\xA1",
+  iquest: "\xBF",
+  acute: "\xB4",
+  cedil: "\xB8",
+  ordf: "\xAA",
+  ordm: "\xBA",
+  sup1: "\xB9",
+  sup2: "\xB2",
+  sup3: "\xB3",
+  frac12: "\xBD",
+  frac14: "\xBC"
+};
+function execAt(re, input, pos) {
+  re.lastIndex = pos;
+  return re.exec(input);
+}
+function parseInline(input) {
+  const nodes = [];
+  const len = input.length;
+  let pos = 0;
+  let textStart = 0;
+  function flushText() {
+    if (pos > textStart) {
+      nodes.push(createText(input.slice(textStart, pos)));
+    }
+  }
+  while (pos < len) {
+    const ch = input.charCodeAt(pos);
+    if (ch === 10) {
+      const prevText = input.slice(textStart, pos);
+      if (prevText.endsWith("  ") || prevText.endsWith("\\")) {
+        const trimmed = prevText.charCodeAt(prevText.length - 1) === 92 ? prevText.slice(0, -1) : prevText.replace(/ +$/, "");
+        if (trimmed) nodes.push(createText(trimmed));
+        nodes.push(createBreak());
+      } else {
+        const trimmedPrev = prevText.replace(/ +$/, "");
+        if (trimmedPrev) nodes.push(createText(trimmedPrev));
+        else flushText();
+        nodes.push(createSoftBreak());
+      }
+      pos++;
+      while (pos < len && input.charCodeAt(pos) === 32) pos++;
+      textStart = pos;
+      continue;
+    }
+    if (ch === 92 && pos + 1 < len) {
+      const next = input[pos + 1];
+      if (RE_ESCAPE.test(next)) {
+        flushText();
+        pos++;
+        textStart = pos;
+        pos++;
+        continue;
+      }
+    }
+    if (ch === 96) {
+      const result = tryInlineCode(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 36 && input.charCodeAt(pos + 1) !== 36) {
+      const result = tryMathInline(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 33 && input.charCodeAt(pos + 1) === 33 && input.charCodeAt(pos + 2) === 33) {
+      const match = execAt(RE_CHERRY_BGCOLOR, input, pos);
+      if (match) {
+        flushText();
+        nodes.push(createFontBgColor(match[1], parseInlineFast(match[2])));
+        pos = pos + match[0].length;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 33 && input.charCodeAt(pos + 1) === 33 && input.charCodeAt(pos + 2) !== 33) {
+      const match = execAt(RE_CHERRY_COLOR, input, pos);
+      if (match) {
+        flushText();
+        nodes.push(createFontColor(match[1], parseInlineFast(match[2])));
+        pos = pos + match[0].length;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 33) {
+      const next = input.charCodeAt(pos + 1);
+      if (next !== 33 && next !== 91 && next !== 97 && next !== 118) {
+        const match = execAt(RE_CHERRY_SIZE, input, pos);
+        if (match) {
+          flushText();
+          nodes.push(createFontSize(match[1] + "px", parseInlineFast(match[2])));
+          pos = pos + match[0].length;
+          textStart = pos;
+          continue;
+        }
+      }
+    }
+    if (ch === 33 && input.charCodeAt(pos + 1) === 97) {
+      const match = execAt(RE_AUDIO, input, pos);
+      if (match) {
+        flushText();
+        nodes.push(createAudio(match[2], match[1] || void 0));
+        pos = pos + match[0].length;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 33 && input.charCodeAt(pos + 1) === 118) {
+      const match = execAt(RE_VIDEO, input, pos);
+      if (match) {
+        flushText();
+        nodes.push(createVideo(match[2], match[1] || void 0));
+        pos = pos + match[0].length;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 33 && input.charCodeAt(pos + 1) === 91) {
+      const result = tryImage(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 91) {
+      if (input.charCodeAt(pos + 1) === 94) {
+        const match = execAt(RE_FOOTNOTE_REF, input, pos);
+        if (match) {
+          flushText();
+          nodes.push(createFootnoteReference(match[1], match[1]));
+          pos = pos + match[0].length;
+          textStart = pos;
+          continue;
+        }
+      }
+      const result = tryLink(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 60) {
+      const uriMatch = execAt(RE_AUTOLINK_URI, input, pos);
+      if (uriMatch) {
+        flushText();
+        nodes.push(createAutolink(uriMatch[1], false));
+        pos = pos + uriMatch[0].length;
+        textStart = pos;
+        continue;
+      }
+      const emailMatch = execAt(RE_AUTOLINK_EMAIL, input, pos);
+      if (emailMatch) {
+        flushText();
+        nodes.push(createAutolink("mailto:" + emailMatch[1], true));
+        pos = pos + emailMatch[0].length;
+        textStart = pos;
+        continue;
+      }
+      const htmlPatterns = [RE_HTML_INLINE_OPEN, RE_HTML_INLINE_CLOSE, RE_HTML_COMMENT, RE_HTML_PI, RE_HTML_CDATA, RE_HTML_DECL];
+      let htmlMatched = false;
+      for (let hi = 0; hi < htmlPatterns.length; hi++) {
+        const hm = execAt(htmlPatterns[hi], input, pos);
+        if (hm) {
+          flushText();
+          nodes.push(createHtmlInline(hm[0]));
+          pos = pos + hm[0].length;
+          textStart = pos;
+          htmlMatched = true;
+          break;
+        }
+      }
+      if (htmlMatched) continue;
+    }
+    if (ch === 42 || ch === 95) {
+      const result = tryEmphasis(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 126 && input.charCodeAt(pos + 1) === 126) {
+      const result = tryStrikethrough(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 61 && input.charCodeAt(pos + 1) === 61) {
+      const result = tryHighlight(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 94 && input.charCodeAt(pos + 1) !== 94) {
+      const result = trySuperscript(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 94 && input.charCodeAt(pos + 1) === 94) {
+      const result = tryCherrySubscript(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 126 && input.charCodeAt(pos + 1) !== 126) {
+      const result = trySubscript(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 123) {
+      const colorMatch = execAt(RE_FONT_COLOR, input, pos);
+      if (colorMatch) {
+        const closeTag = "{/color}";
+        const closeIdx = input.indexOf(closeTag, pos + colorMatch[0].length);
+        if (closeIdx !== -1) {
+          const content = input.slice(pos + colorMatch[0].length, closeIdx);
+          if (content.length > 0) {
+            flushText();
+            nodes.push(createFontColor(colorMatch[1], parseInlineFast(content)));
+            pos = closeIdx + closeTag.length;
+            textStart = pos;
+            continue;
+          }
+        }
+      }
+      const sizeMatch = execAt(RE_FONT_SIZE, input, pos);
+      if (sizeMatch) {
+        const closeTag = "{/size}";
+        const closeIdx = input.indexOf(closeTag, pos + sizeMatch[0].length);
+        if (closeIdx !== -1) {
+          const content = input.slice(pos + sizeMatch[0].length, closeIdx);
+          if (content.length > 0) {
+            flushText();
+            nodes.push(createFontSize(sizeMatch[1], parseInlineFast(content)));
+            pos = closeIdx + closeTag.length;
+            textStart = pos;
+            continue;
+          }
+        }
+      }
+      const bgMatch = execAt(RE_FONT_BGCOLOR, input, pos);
+      if (bgMatch) {
+        const closeTag = "{/bgcolor}";
+        const closeIdx = input.indexOf(closeTag, pos + bgMatch[0].length);
+        if (closeIdx !== -1) {
+          const content = input.slice(pos + bgMatch[0].length, closeIdx);
+          if (content.length > 0) {
+            flushText();
+            nodes.push(createFontBgColor(bgMatch[1], parseInlineFast(content)));
+            pos = closeIdx + closeTag.length;
+            textStart = pos;
+            continue;
+          }
+        }
+      }
+      const result = tryRuby(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 47) {
+      const result = tryUnderline(input, pos);
+      if (result) {
+        flushText();
+        nodes.push(result.node);
+        pos = result.end;
+        textStart = pos;
+        continue;
+      }
+    }
+    if (ch === 58) {
+      const match = execAt(RE_EMOJI, input, pos);
+      if (match) {
+        const value = EMOJI_MAP[match[1]];
+        if (value) {
+          flushText();
+          nodes.push(createEmoji(match[1], value));
+          pos = pos + match[0].length;
+          textStart = pos;
+          continue;
+        }
+      }
+    }
+    if (ch === 38) {
+      const match = execAt(RE_ENTITY, input, pos);
+      if (match) {
+        let decoded;
+        if (match[1]) {
+          const code = parseInt(match[1], 16);
+          decoded = code === 0 ? "\uFFFD" : String.fromCodePoint(code);
+        } else if (match[2]) {
+          const code = parseInt(match[2], 10);
+          decoded = code === 0 ? "\uFFFD" : String.fromCodePoint(code);
+        } else if (match[3]) {
+          decoded = HTML_ENTITIES[match[3]];
+        }
+        if (decoded !== void 0) {
+          flushText();
+          nodes.push(createText(decoded));
+          pos = pos + match[0].length;
+          textStart = pos;
+          continue;
+        }
+      }
+    }
+    pos++;
+  }
+  if (textStart < len) {
+    nodes.push(createText(input.slice(textStart)));
+  }
+  return nodes;
+}
+var INLINE_SPECIAL_CHARS = /[`*_~\[!<$\\={^:/{}\n]/;
+function parseInlineFast(content) {
+  if (!INLINE_SPECIAL_CHARS.test(content)) {
+    return content.length > 0 ? [createText(content)] : [];
+  }
+  return parseInline(content);
+}
+function tryInlineCode(input, start) {
+  let pos = start;
+  let ticks = 0;
+  while (pos < input.length && input.charCodeAt(pos) === 96) {
+    ticks++;
+    pos++;
+  }
+  let searchPos = pos;
+  while (searchPos < input.length) {
+    while (searchPos < input.length && input.charCodeAt(searchPos) !== 96) searchPos++;
+    if (searchPos >= input.length) return null;
+    let runStart = searchPos;
+    while (searchPos < input.length && input.charCodeAt(searchPos) === 96) searchPos++;
+    const runLen = searchPos - runStart;
+    if (runLen === ticks) {
+      const content = input.slice(pos, runStart);
+      let trimmed = content;
+      if (content.includes("\n")) trimmed = content.replace(/\n/g, " ");
+      const normalized = trimmed.length > 0 && trimmed.charCodeAt(0) === 32 && trimmed.charCodeAt(trimmed.length - 1) === 32 && trimmed.trim().length > 0 ? trimmed.slice(1, -1) : trimmed;
+      return {
+        node: createInlineCode(normalized),
+        end: runStart + ticks
+      };
+    }
+  }
+  return null;
+}
+function tryMathInline(input, start) {
+  const pos = start + 1;
+  const closePos = input.indexOf("$", pos);
+  if (closePos === -1 || closePos === pos) return null;
+  if (input.charCodeAt(pos) === 32 || input.charCodeAt(closePos - 1) === 32) return null;
+  return {
+    node: createMathInline(input.slice(pos, closePos)),
+    end: closePos + 1
+  };
+}
+function tryImage(input, start) {
+  const altClose = findClosingBracket(input, start + 1);
+  if (altClose === -1 || input.charCodeAt(altClose + 1) !== 40) return null;
+  const alt = input.slice(start + 2, altClose);
+  const urlResult = parseUrlAndTitle(input, altClose + 1);
+  if (!urlResult) return null;
+  return {
+    node: createImage(urlResult.url, alt, urlResult.title),
+    end: urlResult.end
+  };
+}
+function tryLink(input, start) {
+  const textClose = findClosingBracket(input, start);
+  if (textClose === -1 || input.charCodeAt(textClose + 1) !== 40) return null;
+  const text = input.slice(start + 1, textClose);
+  const urlResult = parseUrlAndTitle(input, textClose + 1);
+  if (!urlResult) return null;
+  return {
+    node: createLink(urlResult.url, parseInlineFast(text), urlResult.title),
+    end: urlResult.end
+  };
+}
+function tryEmphasis(input, start) {
+  const charCode = input.charCodeAt(start);
+  let count = 1;
+  while (start + count < input.length && input.charCodeAt(start + count) === charCode) count++;
+  if (count > 3) count = 3;
+  const pos = start + count;
+  let searchPos = pos;
+  while (searchPos < input.length) {
+    let closeIdx = -1;
+    for (let k = searchPos; k < input.length; k++) {
+      if (input.charCodeAt(k) === charCode) {
+        closeIdx = k;
+        break;
+      }
+    }
+    if (closeIdx === -1) return null;
+    let closeCount = 1;
+    while (closeIdx + closeCount < input.length && input.charCodeAt(closeIdx + closeCount) === charCode) closeCount++;
+    if (closeCount < count) {
+      searchPos = closeIdx + closeCount;
+      continue;
+    }
+    const actualCloseStart = closeIdx + closeCount - count;
+    const content = input.slice(pos, actualCloseStart);
+    if (content.length === 0) {
+      searchPos = closeIdx + closeCount;
+      continue;
+    }
+    const children = parseInlineFast(content);
+    const end = actualCloseStart + count;
+    if (count === 1) {
+      return { node: createEmphasis(children), end };
+    } else if (count === 2) {
+      return { node: createStrong(children), end };
+    } else {
+      return { node: createStrong([createEmphasis(children)]), end };
+    }
+  }
+  return null;
+}
+function tryStrikethrough(input, start) {
+  for (let k = start + 2; k < input.length - 1; k++) {
+    if (input.charCodeAt(k) === 126 && input.charCodeAt(k + 1) === 126) {
+      const content = input.slice(start + 2, k);
+      if (content.length === 0) return null;
+      return { node: createStrikethrough(parseInlineFast(content)), end: k + 2 };
+    }
+  }
+  return null;
+}
+function tryHighlight(input, start) {
+  for (let k = start + 2; k < input.length - 1; k++) {
+    if (input.charCodeAt(k) === 61 && input.charCodeAt(k + 1) === 61) {
+      const content = input.slice(start + 2, k);
+      if (content.length === 0) return null;
+      return { node: createHighlight(parseInlineFast(content)), end: k + 2 };
+    }
+  }
+  return null;
+}
+function trySuperscript(input, start) {
+  const closeIdx = input.indexOf("^", start + 1);
+  if (closeIdx === -1 || closeIdx === start + 1) return null;
+  const content = input.slice(start + 1, closeIdx);
+  if (content.includes(" ")) return null;
+  return { node: createSuperscript(parseInlineFast(content)), end: closeIdx + 1 };
+}
+function trySubscript(input, start) {
+  if (input.charCodeAt(start + 1) === 126) return null;
+  const closeIdx = input.indexOf("~", start + 1);
+  if (closeIdx === -1 || closeIdx === start + 1) return null;
+  const content = input.slice(start + 1, closeIdx);
+  if (content.includes(" ")) return null;
+  return { node: createSubscript(parseInlineFast(content)), end: closeIdx + 1 };
+}
+function tryCherrySubscript(input, start) {
+  const closeIdx = input.indexOf("^^", start + 2);
+  if (closeIdx === -1) return null;
+  const content = input.slice(start + 2, closeIdx);
+  if (content.length === 0) return null;
+  return { node: createSubscript(parseInlineFast(content)), end: closeIdx + 2 };
+}
+function findClosingBracket(input, start) {
+  let depth = 0;
+  let pos = start;
+  while (pos < input.length) {
+    const c = input.charCodeAt(pos);
+    if (c === 91) depth++;
+    else if (c === 93) {
+      depth--;
+      if (depth === 0) return pos;
+    } else if (c === 92) {
+      pos++;
+    }
+    pos++;
+  }
+  return -1;
+}
+function parseUrlAndTitle(input, start) {
+  if (input.charCodeAt(start) !== 40) return null;
+  let pos = start + 1;
+  while (pos < input.length && isWhitespace(input.charCodeAt(pos))) pos++;
+  let url = "";
+  if (input.charCodeAt(pos) === 60) {
+    const closeAngle = input.indexOf(">", pos + 1);
+    if (closeAngle === -1) return null;
+    url = input.slice(pos + 1, closeAngle);
+    pos = closeAngle + 1;
+  } else {
+    let depth = 0;
+    const urlStart = pos;
+    while (pos < input.length) {
+      const c = input.charCodeAt(pos);
+      if (c === 40) depth++;
+      else if (c === 41) {
+        if (depth === 0) break;
+        depth--;
+      } else if (isWhitespace(c)) break;
+      pos++;
+    }
+    url = input.slice(urlStart, pos);
+  }
+  while (pos < input.length && isWhitespace(input.charCodeAt(pos))) pos++;
+  let title;
+  const tc = input.charCodeAt(pos);
+  if (tc === 34 || tc === 39 || tc === 40) {
+    const quote = tc === 40 ? 41 : tc;
+    const titleStart = pos + 1;
+    pos++;
+    while (pos < input.length && input.charCodeAt(pos) !== quote) {
+      if (input.charCodeAt(pos) === 92) pos++;
+      pos++;
+    }
+    if (pos >= input.length) return null;
+    title = input.slice(titleStart, pos);
+    pos++;
+  }
+  while (pos < input.length && isWhitespace(input.charCodeAt(pos))) pos++;
+  if (pos >= input.length || input.charCodeAt(pos) !== 41) return null;
+  return { url: decodeEntities(decodeBackslashEscapes(url)), title: title ? decodeEntities(decodeBackslashEscapes(title)) : title, end: pos + 1 };
+}
+function isWhitespace(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13;
+}
+var RE_BACKSLASH_ESCAPE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
+function decodeBackslashEscapes(str) {
+  return str.replace(RE_BACKSLASH_ESCAPE, "$1");
+}
+function decodeEntities(str) {
+  if (!str.includes("&")) return str;
+  return str.replace(/&(?:#[xX]([0-9a-fA-F]{1,6})|#([0-9]{1,7})|([a-zA-Z][a-zA-Z0-9]{1,31}));/g, (match, hex, dec, name) => {
+    if (hex) {
+      const code = parseInt(hex, 16);
+      return code === 0 ? "\uFFFD" : String.fromCodePoint(code);
+    }
+    if (dec) {
+      const code = parseInt(dec, 10);
+      return code === 0 ? "\uFFFD" : String.fromCodePoint(code);
+    }
+    if (name && HTML_ENTITIES[name]) {
+      return HTML_ENTITIES[name];
+    }
+    return match;
+  });
+}
+function tryRuby(input, start) {
+  const braceClose = input.indexOf("}", start + 1);
+  if (braceClose === -1) return null;
+  const innerContent = input.slice(start + 1, braceClose);
+  if (innerContent.length === 0) return null;
+  if (innerContent.charCodeAt(0) === 99 && innerContent.startsWith("color:")) return null;
+  if (innerContent.charCodeAt(0) === 115 && innerContent.startsWith("size:")) return null;
+  if (innerContent.charCodeAt(0) === 98 && innerContent.startsWith("bgcolor:")) return null;
+  if (innerContent.charCodeAt(0) === 47) return null;
+  const pipeIdx = innerContent.indexOf("|");
+  if (pipeIdx !== -1) {
+    const base = innerContent.slice(0, pipeIdx);
+    const annotation2 = innerContent.slice(pipeIdx + 1);
+    if (base.length > 0 && annotation2.length > 0) {
+      return { node: createRuby(base, annotation2), end: braceClose + 1 };
+    }
+  }
+  if (input.charCodeAt(braceClose + 1) !== 40) return null;
+  const parenClose = input.indexOf(")", braceClose + 2);
+  if (parenClose === -1) return null;
+  const annotation = input.slice(braceClose + 2, parenClose);
+  if (annotation.length === 0) return null;
+  return { node: createRuby(innerContent, annotation), end: parenClose + 1 };
+}
+function tryUnderline(input, start) {
+  if (start > 0 && input.charCodeAt(start - 1) !== 32 && input.charCodeAt(start - 1) !== 10) return null;
+  const closeIdx = input.indexOf("/", start + 1);
+  if (closeIdx === -1 || closeIdx === start + 1) return null;
+  const content = input.slice(start + 1, closeIdx);
+  if (content.includes("\n")) return null;
+  if (closeIdx + 1 < input.length && input.charCodeAt(closeIdx + 1) !== 32 && input.charCodeAt(closeIdx + 1) !== 10) return null;
+  return { node: createUnderline(parseInlineFast(content)), end: closeIdx + 1 };
+}
+var EMOJI_MAP = {
+  smile: "\u{1F604}",
+  laughing: "\u{1F606}",
+  blush: "\u{1F60A}",
+  smiley: "\u{1F603}",
+  relaxed: "\u263A\uFE0F",
+  heart: "\u2764\uFE0F",
+  "thumbsup": "\u{1F44D}",
+  "thumbsdown": "\u{1F44E}",
+  ok_hand: "\u{1F44C}",
+  wave: "\u{1F44B}",
+  clap: "\u{1F44F}",
+  raised_hands: "\u{1F64C}",
+  pray: "\u{1F64F}",
+  fire: "\u{1F525}",
+  star: "\u2B50",
+  sparkles: "\u2728",
+  zap: "\u26A1",
+  warning: "\u26A0\uFE0F",
+  x: "\u274C",
+  white_check_mark: "\u2705",
+  question: "\u2753",
+  exclamation: "\u2757",
+  bulb: "\u{1F4A1}",
+  memo: "\u{1F4DD}",
+  book: "\u{1F4D6}",
+  rocket: "\u{1F680}",
+  tada: "\u{1F389}",
+  eyes: "\u{1F440}",
+  thinking: "\u{1F914}",
+  sob: "\u{1F62D}",
+  joy: "\u{1F602}",
+  wink: "\u{1F609}",
+  grin: "\u{1F601}",
+  sweat_smile: "\u{1F605}",
+  sunglasses: "\u{1F60E}",
+  heart_eyes: "\u{1F60D}",
+  100: "\u{1F4AF}",
+  boom: "\u{1F4A5}",
+  muscle: "\u{1F4AA}",
+  point_up: "\u261D\uFE0F",
+  point_down: "\u{1F447}",
+  point_left: "\u{1F448}",
+  point_right: "\u{1F449}",
+  see_no_evil: "\u{1F648}",
+  hear_no_evil: "\u{1F649}",
+  speak_no_evil: "\u{1F64A}",
+  coffee: "\u2615",
+  beer: "\u{1F37A}",
+  pizza: "\u{1F355}",
+  hamburger: "\u{1F354}",
+  dog: "\u{1F436}",
+  cat: "\u{1F431}",
+  bug: "\u{1F41B}",
+  penguin: "\u{1F427}",
+  checkered_flag: "\u{1F3C1}",
+  trophy: "\u{1F3C6}",
+  gem: "\u{1F48E}",
+  wrench: "\u{1F527}",
+  hammer: "\u{1F528}",
+  gear: "\u2699\uFE0F",
+  link: "\u{1F517}",
+  lock: "\u{1F512}",
+  key: "\u{1F511}",
+  bell: "\u{1F514}",
+  calendar: "\u{1F4C5}",
+  clock: "\u{1F550}",
+  earth_americas: "\u{1F30E}",
+  sunny: "\u2600\uFE0F",
+  cloud: "\u2601\uFE0F",
+  umbrella: "\u2602\uFE0F",
+  snowflake: "\u2744\uFE0F",
+  rainbow: "\u{1F308}",
+  ocean: "\u{1F30A}",
+  "+1": "\u{1F44D}",
+  "-1": "\u{1F44E}"
+};
+
+// src/block/parser.ts
+var DEFAULT_OPTIONS = {
+  gfmTables: true,
+  mathBlocks: true,
+  containers: true,
+  toc: true,
+  footnotes: true,
+  lazyInline: false
+};
+var RE_ATX_HEADING = /^(#{1,6})(?:\s|$)/;
+var RE_SETEXT_H1 = /^ {0,3}={1,}[ \t]*$/;
+var RE_SETEXT_H2 = /^ {0,3}-{1,}[ \t]*$/;
+var RE_THEMATIC_BREAK = /^(?:\*[ \t]*){3,}$|^(?:-[ \t]*){3,}$|^(?:_[ \t]*){3,}$/;
+var RE_UL_MARKER = /^([*+-])(\s+|$)/;
+var RE_OL_MARKER = /^(\d{1,9})([.)])(\s+|$)/;
+var RE_BLOCKQUOTE = /^>[ \t]?/;
+var RE_FENCE_OPEN = /^(`{3,}|~{3,})(?:\s*(\S+)?.*)?$/;
+var RE_MATH_OPEN = /^\${2}\s*$/;
+var RE_MATH_CLOSE = /^\${2}\s*$/;
+var RE_CONTAINER_OPEN = /^:::[ \t]*(\w+)(?:[ \t]+(.*))?$/;
+var RE_CONTAINER_CLOSE = /^:::[ \t]*$/;
+var RE_TOC = /^(?:\[toc\]|\[\[toc\]\]|【【toc】】)$/i;
+var RE_TABLE_DELIM = /^\|?(?:\s*:?-+:?\s*\|)+\s*:?-+:?\s*\|?\s*$/;
+var RE_HTML_BLOCK_1 = /^<(?:script|pre|style|textarea)(?:\s|>|$)/i;
+var RE_HTML_BLOCK_2 = /^<!--/;
+var RE_HTML_BLOCK_3 = /^<\?/;
+var RE_HTML_BLOCK_4 = /^<![A-Z]/;
+var RE_HTML_BLOCK_5 = /^<!\[CDATA\[/;
+var RE_HTML_BLOCK_6 = /^<\/?(?: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|h1|h2|h3|h4|h5|h6|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 RE_HTML_BLOCK_7_OPEN = /^<[a-zA-Z][a-zA-Z0-9-]*(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^\s"'=<>`]+|'[^']*'|"[^"]*"))?)*\s*\/?>[ \t]*$/;
+var RE_HTML_BLOCK_7_CLOSE = /^<\/[a-zA-Z][a-zA-Z0-9-]*\s*>[ \t]*$/;
+var RE_TASK = /^\[([ xX])\]\s+/;
+var RE_FOOTNOTE_DEF = /^\[\^([^\]]+)\]:\s+(.*)/;
+var RE_DETAIL_OPEN = /^\+\+\+([-]?)\s+(.+)$/;
+var RE_DETAIL_CLOSE = /^\+\+\+\s*$/;
+var RE_FRONTMATTER_OPEN = /^-{3,}\s*$/;
+function isIndentCode(s) {
+  const c = s.charCodeAt(0);
+  if (c === 9) return true;
+  return c === 32 && s.charCodeAt(1) === 32 && s.charCodeAt(2) === 32 && s.charCodeAt(3) === 32;
+}
+function isBlank(s) {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c !== 32 && c !== 9) return false;
+  }
+  return true;
+}
+function strip3(s) {
+  const c0 = s.charCodeAt(0);
+  if (c0 !== 32) return s;
+  const c1 = s.charCodeAt(1);
+  if (c1 !== 32) return s.slice(1);
+  const c2 = s.charCodeAt(2);
+  if (c2 !== 32) return s.slice(2);
+  return s.slice(3);
+}
+function parseBlocks(input, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const lines = input.split("\n");
+  const children = parseBlockLines(lines, 0, lines.length, opts);
+  return createDocument(children);
+}
+function parseBlockLines(lines, start, end, opts) {
+  const blocks = [];
+  let i = start;
+  while (i < end) {
+    const line = lines[i];
+    if (isBlank(line)) {
+      i++;
+      continue;
+    }
+    let result;
+    const firstChar = line.charCodeAt(0);
+    let trimStart = -1;
+    for (let k = 0; k < line.length; k++) {
+      const c = line.charCodeAt(k);
+      if (c !== 32 && c !== 9) {
+        trimStart = k;
+        break;
+      }
+    }
+    const fc = trimStart >= 0 ? line.charCodeAt(trimStart) : firstChar;
+    if (blocks.length === 0 && i === start && fc === 45) {
+      result = tryFrontMatter(lines, i, end);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (fc === 35 || firstChar === 32 && trimStart <= 3 && trimStart >= 0 && line.charCodeAt(trimStart) === 35) {
+      result = tryATXHeading(lines, i, opts);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (fc === 42 || fc === 45 || fc === 95) {
+      result = tryThematicBreak(lines, i);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (fc === 96 || fc === 126) {
+      result = tryFencedCode(lines, i, end);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (opts.mathBlocks && fc === 36) {
+      result = tryMathBlock(lines, i, end);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (opts.toc && (fc === 91 || fc === 12304)) {
+      result = tryTOC(lines, i);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (opts.footnotes && fc === 91) {
+      result = tryFootnoteDefinition(lines, i, end, opts);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (opts.containers && fc === 58) {
+      result = tryContainer(lines, i, end, opts);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (fc === 43) {
+      result = tryDetail(lines, i, end, opts);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (fc === 62) {
+      result = tryBlockquote(lines, i, end, opts);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (fc === 45 || fc === 42 || fc === 43 || fc >= 48 && fc <= 57) {
+      result = tryList(lines, i, end, opts);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (fc === 60) {
+      result = tryHtmlBlock(lines, i, end);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (opts.gfmTables && line.includes("|")) {
+      result = tryTable(lines, i, end, opts);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    if (firstChar === 32 || firstChar === 9) {
+      result = tryIndentedCode(lines, i, end);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
+    result = tryParagraphOrSetext(lines, i, end, opts);
+    if (result) {
+      blocks.push(result.node);
+      i = result.nextLine;
+      continue;
+    }
+    i++;
+  }
+  return blocks;
+}
+function inlineOrLazy(content, opts) {
+  if (opts.lazyInline) return [];
+  return parseInline(content);
+}
+function tryATXHeading(lines, i, _opts) {
+  let line = lines[i];
+  const stripped = strip3(line);
+  const match = RE_ATX_HEADING.exec(stripped);
+  if (!match) return null;
+  const depth = match[1].length;
+  let content = stripped.slice(match[0].length);
+  content = content.replace(/\s+#+\s*$/, "");
+  if (/^#+\s*$/.test(content)) content = "";
+  content = content.trim();
+  const children = content ? inlineOrLazy(content, _opts) : [];
+  const node = createHeading(depth, children);
+  if (_opts.lazyInline && content) node._raw = content;
+  return {
+    node,
+    nextLine: i + 1
+  };
+}
+function tryThematicBreak(lines, i) {
+  const line = lines[i];
+  const stripped = strip3(line);
+  if (!RE_THEMATIC_BREAK.test(stripped)) return null;
+  return {
+    node: createThematicBreak(),
+    nextLine: i + 1
+  };
+}
+function tryFencedCode(lines, i, end) {
+  const line = lines[i];
+  let indent = 0;
+  while (indent < 3 && indent < line.length && line.charCodeAt(indent) === 32) indent++;
+  const stripped = line.slice(indent);
+  const openMatch = RE_FENCE_OPEN.exec(stripped);
+  if (!openMatch) return null;
+  const fence = openMatch[1];
+  const rawLang = openMatch[2] ?? void 0;
+  const isBacktick = fence[0] === "`";
+  const fenceLen = fence.length;
+  if (isBacktick) {
+    const afterFence = stripped.slice(fenceLen);
+    if (afterFence.includes("`")) return null;
+  }
+  const lang = rawLang ? decodeInfoString(rawLang) : void 0;
+  const contentLines = [];
+  let j = i + 1;
+  while (j < end) {
+    const current = lines[j];
+    const closeStripped = strip3(current);
+    if (isBacktick && /^`{3,}\s*$/.test(closeStripped) && closeStripped.trim().length >= fenceLen) {
+      j++;
+      break;
+    }
+    if (!isBacktick && /^~{3,}\s*$/.test(closeStripped) && closeStripped.trim().length >= fenceLen) {
+      j++;
+      break;
+    }
+    if (indent > 0 && current.length > 0) {
+      let strip = 0;
+      for (let k = 0; k < indent && k < current.length && current[k] === " "; k++) strip++;
+      contentLines.push(current.slice(strip));
+    } else {
+      contentLines.push(current);
+    }
+    j++;
+  }
+  return {
+    node: createCodeBlock(contentLines.join("\n"), lang),
+    nextLine: j
+  };
+}
+function tryMathBlock(lines, i, end) {
+  const line = lines[i];
+  if (!RE_MATH_OPEN.test(line)) return null;
+  const contentLines = [];
+  let j = i + 1;
+  while (j < end) {
+    if (RE_MATH_CLOSE.test(lines[j])) {
+      j++;
+      break;
+    }
+    contentLines.push(lines[j]);
+    j++;
+  }
+  return {
+    node: createMathBlock(contentLines.join("\n")),
+    nextLine: j
+  };
+}
+function tryTOC(lines, i) {
+  const line = lines[i].trim();
+  if (!RE_TOC.test(line)) return null;
+  return {
+    node: createTOC(),
+    nextLine: i + 1
+  };
+}
+function expandContainerKind(raw) {
+  switch (raw.toLowerCase()) {
+    case "p":
+      return "primary";
+    case "i":
+      return "info";
+    case "w":
+      return "warning";
+    case "d":
+      return "danger";
+    case "s":
+      return "success";
+    case "l":
+      return "left";
+    case "c":
+      return "center";
+    case "r":
+      return "right";
+    case "j":
+      return "justify";
+    case "tip":
+      return "info";
+    default:
+      return raw;
+  }
+}
+function tryContainer(lines, i, end, opts) {
+  const line = lines[i];
+  const openMatch = RE_CONTAINER_OPEN.exec(line);
+  if (!openMatch) return null;
+  const rawKind = openMatch[1];
+  const title = openMatch[2] ?? void 0;
+  const kind = expandContainerKind(rawKind);
+  const contentLines = [];
+  let j = i + 1;
+  while (j < end) {
+    if (RE_CONTAINER_CLOSE.test(lines[j])) {
+      j++;
+      break;
+    }
+    contentLines.push(lines[j]);
+    j++;
+  }
+  const children = parseBlockLines(contentLines, 0, contentLines.length, opts);
+  return {
+    node: createContainer(kind, children, title),
+    nextLine: j
+  };
+}
+function tryBlockquote(lines, i, end, opts) {
+  const line = lines[i];
+  const stripped = strip3(line);
+  if (!RE_BLOCKQUOTE.test(stripped)) return null;
+  const contentLines = [];
+  let j = i;
+  while (j < end) {
+    const current = lines[j];
+    const curStripped = strip3(current);
+    if (RE_BLOCKQUOTE.test(curStripped)) {
+      contentLines.push(curStripped.replace(RE_BLOCKQUOTE, ""));
+      j++;
+    } else if (!isBlank(current) && contentLines.length > 0 && // Don't lazily continue after a blank content line (empty > line)
+    contentLines[contentLines.length - 1].trim().length > 0 && // Don't lazily continue if the line starts a new block element
+    // (reuse curStripped instead of re-computing strip3)
+    !RE_ATX_HEADING.test(curStripped) && !RE_THEMATIC_BREAK.test(curStripped) && !RE_FENCE_OPEN.test(curStripped) && !RE_UL_MARKER.test(curStripped) && !RE_OL_MARKER.test(curStripped) && !RE_HTML_BLOCK_1.test(current) && !RE_HTML_BLOCK_6.test(current) && // Only lazily continue paragraphs, not code blocks or other blocks
+    // Check that last content line is not inside an open fenced code block
+    !isInsideOpenFencedCode(contentLines) && // Don't lazily continue if blockquote content ends with indented code
+    // (i.e., last non-blank content line is indented code)
+    !lastContentIsIndentedCode(contentLines)) {
+      contentLines.push(current);
+      j++;
+    } else {
+      break;
+    }
+  }
+  const children = parseBlockLines(contentLines, 0, contentLines.length, opts);
+  return {
+    node: createBlockquote(children),
+    nextLine: j
+  };
+}
+function isInsideOpenFencedCode(contentLines) {
+  let insideFence = false;
+  let fenceChar = "";
+  let fenceLen = 0;
+  for (const line of contentLines) {
+    const stripped = strip3(line);
+    if (!insideFence) {
+      const openMatch = RE_FENCE_OPEN.exec(stripped);
+      if (openMatch) {
+        insideFence = true;
+        fenceChar = openMatch[1][0];
+        fenceLen = openMatch[1].length;
+      }
+    } else {
+      const closeStripped = stripped;
+      if (fenceChar === "`" && /^`{3,}\s*$/.test(closeStripped) && closeStripped.trim().length >= fenceLen) {
+        insideFence = false;
+      } else if (fenceChar === "~" && /^~{3,}\s*$/.test(closeStripped) && closeStripped.trim().length >= fenceLen) {
+        insideFence = false;
+      }
+    }
+  }
+  return insideFence;
+}
+function lastContentIsIndentedCode(contentLines) {
+  let idx = contentLines.length - 1;
+  while (idx >= 0 && isBlank(contentLines[idx])) {
+    idx--;
+  }
+  if (idx < 0) return false;
+  const lastLine = contentLines[idx];
+  return isIndentCode(lastLine);
+}
+function tryList(lines, i, end, opts) {
+  const line = lines[i];
+  const ulMatch = RE_UL_MARKER.exec(line);
+  const olMatch = RE_OL_MARKER.exec(line);
+  if (!ulMatch && !olMatch) return null;
+  const ordered = !!olMatch;
+  const startNum = olMatch ? parseInt(olMatch[1], 10) : void 0;
+  const items = [];
+  let j = i;
+  let spread = false;
+  while (j < end) {
+    const currentLine = lines[j];
+    const currentUl = RE_UL_MARKER.exec(currentLine);
+    const currentOl = RE_OL_MARKER.exec(currentLine);
+    let isListItem = ordered ? !!currentOl : !!currentUl;
+    if (isListItem && j > i) {
+      const currentStripped = strip3(currentLine);
+      if (RE_THEMATIC_BREAK.test(currentStripped)) {
+        isListItem = false;
+      }
+    }
+    if (!isListItem && j > i) {
+      const currentStripped = strip3(currentLine);
+      if (RE_THEMATIC_BREAK.test(currentStripped)) {
+        break;
+      }
+      if (isBlank(currentLine)) {
+        let k = j + 1;
+        while (k < end && isBlank(lines[k])) k++;
+        if (k < end) {
+          const nextUl = RE_UL_MARKER.exec(lines[k]);
+          const nextOl = RE_OL_MARKER.exec(lines[k]);
+          if (ordered ? !!nextOl : !!nextUl) {
+            spread = true;
+            j++;
+            continue;
+          }
+        }
+        break;
+      }
+      if (/^(?: {2,}|\t)/.test(currentLine)) {
+        j++;
+        continue;
+      }
+      break;
+    }
+    if (!isListItem) break;
+    const marker = ordered ? currentOl : currentUl;
+    const markerWidth = marker[0].length;
+    let content = currentLine.slice(markerWidth);
+    let checked;
+    const taskMatch = RE_TASK.exec(content);
+    if (taskMatch) {
+      checked = taskMatch[1] !== " ";
+      content = content.slice(taskMatch[0].length);
+    }
+    const itemLines = [content];
+    j++;
+    while (j < end) {
+      const itemLine = lines[j];
+      if (isBlank(itemLine)) {
+        if (j + 1 < end && /^(?: {2,}|\t)/.test(lines[j + 1])) {
+          itemLines.push("");
+          j++;
+          continue;
+        }
+        break;
+      }
+      if ((ordered ? RE_OL_MARKER : RE_UL_MARKER).test(itemLine)) break;
+      if (RE_THEMATIC_BREAK.test(strip3(itemLine))) break;
+      if (/^(?: {2,}|\t)/.test(itemLine)) {
+        itemLines.push(itemLine.replace(/^(?: {2,}|\t)/, ""));
+        j++;
+        continue;
+      }
+      itemLines.push(itemLine);
+      j++;
+    }
+    const children = parseBlockLines(itemLines, 0, itemLines.length, opts);
+    items.push(createListItem(children, false, checked));
+  }
+  if (items.length === 0) return null;
+  return {
+    node: createList(ordered, spread, items, startNum),
+    nextLine: j
+  };
+}
+function tryHtmlBlock(lines, i, end) {
+  const line = lines[i];
+  const stripped = strip3(line);
+  if (RE_HTML_BLOCK_1.test(stripped)) {
+    const htmlLines = [];
+    let j = i;
+    while (j < end) {
+      htmlLines.push(lines[j]);
+      if (/<\/(?:script|pre|style|textarea)>/i.test(lines[j])) {
+        j++;
+        break;
+      }
+      j++;
+    }
+    return {
+      node: createHtmlBlock(htmlLines.join("\n")),
+      nextLine: j
+    };
+  }
+  if (RE_HTML_BLOCK_2.test(stripped)) {
+    const htmlLines = [];
+    let j = i;
+    while (j < end) {
+      htmlLines.push(lines[j]);
+      if (lines[j].includes("-->")) {
+        j++;
+        break;
+      }
+      j++;
+    }
+    return {
+      node: createHtmlBlock(htmlLines.join("\n")),
+      nextLine: j
+    };
+  }
+  if (RE_HTML_BLOCK_3.test(stripped)) {
+    const htmlLines = [];
+    let j = i;
+    while (j < end) {
+      htmlLines.push(lines[j]);
+      if (lines[j].includes("?>")) {
+        j++;
+        break;
+      }
+      j++;
+    }
+    return { node: createHtmlBlock(htmlLines.join("\n")), nextLine: j };
+  }
+  if (RE_HTML_BLOCK_4.test(stripped)) {
+    const htmlLines = [];
+    let j = i;
+    while (j < end) {
+      htmlLines.push(lines[j]);
+      if (lines[j].includes(">")) {
+        j++;
+        break;
+      }
+      j++;
+    }
+    return { node: createHtmlBlock(htmlLines.join("\n")), nextLine: j };
+  }
+  if (RE_HTML_BLOCK_5.test(stripped)) {
+    const htmlLines = [];
+    let j = i;
+    while (j < end) {
+      htmlLines.push(lines[j]);
+      if (lines[j].includes("]]>")) {
+        j++;
+        break;
+      }
+      j++;
+    }
+    return { node: createHtmlBlock(htmlLines.join("\n")), nextLine: j };
+  }
+  if (RE_HTML_BLOCK_6.test(stripped)) {
+    const htmlLines = [];
+    let j = i;
+    while (j < end) {
+      if (j > i && isBlank(lines[j])) break;
+      htmlLines.push(lines[j]);
+      j++;
+    }
+    return {
+      node: createHtmlBlock(htmlLines.join("\n")),
+      nextLine: j
+    };
+  }
+  if (RE_HTML_BLOCK_7_OPEN.test(stripped) || RE_HTML_BLOCK_7_CLOSE.test(stripped)) {
+    const htmlLines = [];
+    let j = i;
+    while (j < end) {
+      if (j > i && isBlank(lines[j])) break;
+      htmlLines.push(lines[j]);
+      j++;
+    }
+    return {
+      node: createHtmlBlock(htmlLines.join("\n")),
+      nextLine: j
+    };
+  }
+  return null;
+}
+function tryTable(lines, i, end, _opts) {
+  if (i + 1 >= end) return null;
+  const headerLine = lines[i];
+  const delimLine = lines[i + 1];
+  if (!RE_TABLE_DELIM.test(delimLine)) return null;
+  if (!headerLine.includes("|")) return null;
+  const align = parseTableAlign(delimLine);
+  const headerCells = parseTableRow(headerLine);
+  const headerRow = createTableRow(
+    true,
+    headerCells.map((cellText) => {
+      const cell = createTableCell(inlineOrLazy(cellText, _opts));
+      if (_opts.lazyInline && cellText) cell._raw = cellText;
+      return cell;
+    })
+  );
+  const rows = [headerRow];
+  let j = i + 2;
+  while (j < end) {
+    const rowLine = lines[j];
+    if (isBlank(rowLine)) break;
+    if (!rowLine.includes("|")) break;
+    const cells = parseTableRow(rowLine);
+    rows.push(
+      createTableRow(
+        false,
+        cells.map((cellText) => {
+          const cell = createTableCell(inlineOrLazy(cellText, _opts));
+          if (_opts.lazyInline && cellText) cell._raw = cellText;
+          return cell;
+        })
+      )
+    );
+    j++;
+  }
+  return {
+    node: createTable(align, rows),
+    nextLine: j
+  };
+}
+function parseTableAlign(delim) {
+  return delim.replace(/^\||\|$/g, "").split("|").map((cell) => {
+    const trimmed = cell.trim();
+    const left = trimmed.startsWith(":");
+    const right = trimmed.endsWith(":");
+    if (left && right) return "center";
+    if (right) return "right";
+    if (left) return "left";
+    return null;
+  });
+}
+function parseTableRow(line) {
+  let trimmed = line.trim();
+  if (trimmed.startsWith("|")) trimmed = trimmed.slice(1);
+  if (trimmed.endsWith("|")) trimmed = trimmed.slice(0, -1);
+  return trimmed.split("|").map((cell) => cell.trim());
+}
+function tryIndentedCode(lines, i, end) {
+  const line = lines[i];
+  if (!isIndentCode(line)) return null;
+  const codeLines = [];
+  let j = i;
+  while (j < end) {
+    const current = lines[j];
+    if (isIndentCode(current)) {
+      codeLines.push(current.replace(/^(?: {4}|\t)/, ""));
+      j++;
+    } else if (isBlank(current)) {
+      codeLines.push("");
+      j++;
+    } else {
+      break;
+    }
+  }
+  while (codeLines.length > 0 && codeLines[codeLines.length - 1] === "") {
+    codeLines.pop();
+  }
+  if (codeLines.length === 0) return null;
+  return {
+    node: createCodeBlock(codeLines.join("\n")),
+    nextLine: j
+  };
+}
+function tryParagraphOrSetext(lines, i, end, _opts) {
+  const paragraphLines = [];
+  let j = i;
+  while (j < end) {
+    const current = lines[j];
+    if (isBlank(current)) break;
+    if (paragraphLines.length > 0) {
+      if (RE_SETEXT_H1.test(current)) {
+        const content2 = paragraphLines.join("\n").trim();
+        const node2 = createHeading(1, inlineOrLazy(content2, _opts));
+        if (_opts.lazyInline && content2) node2._raw = content2;
+        return {
+          node: node2,
+          nextLine: j + 1
+        };
+      }
+      if (RE_SETEXT_H2.test(current)) {
+        const content2 = paragraphLines.join("\n").trim();
+        const node2 = createHeading(2, inlineOrLazy(content2, _opts));
+        if (_opts.lazyInline && content2) node2._raw = content2;
+        return {
+          node: node2,
+          nextLine: j + 1
+        };
+      }
+    }
+    if (paragraphLines.length > 0) {
+      const currentStripped = strip3(current);
+      if (RE_ATX_HEADING.test(currentStripped) || RE_THEMATIC_BREAK.test(currentStripped) || RE_FENCE_OPEN.test(currentStripped) || RE_BLOCKQUOTE.test(currentStripped) || RE_HTML_BLOCK_1.test(currentStripped) || RE_HTML_BLOCK_2.test(currentStripped) || RE_HTML_BLOCK_3.test(currentStripped) || RE_HTML_BLOCK_4.test(currentStripped) || RE_HTML_BLOCK_5.test(currentStripped) || RE_HTML_BLOCK_6.test(currentStripped)) {
+        break;
+      }
+    }
+    paragraphLines.push(current.replace(/^ {1,3}(?! )/, ""));
+    j++;
+  }
+  if (paragraphLines.length === 0) return null;
+  const content = paragraphLines.join("\n").trim();
+  const node = createParagraph(inlineOrLazy(content, _opts));
+  if (_opts.lazyInline && content) node._raw = content;
+  return {
+    node,
+    nextLine: j
+  };
+}
+function tryFrontMatter(lines, i, end) {
+  const line = lines[i];
+  if (!RE_FRONTMATTER_OPEN.test(line)) return null;
+  const contentLines = [];
+  let j = i + 1;
+  let foundClose = false;
+  while (j < end) {
+    if (RE_FRONTMATTER_OPEN.test(lines[j])) {
+      foundClose = true;
+      j++;
+      break;
+    }
+    contentLines.push(lines[j]);
+    j++;
+  }
+  if (!foundClose) return null;
+  const hasContent = contentLines.some((l) => l.trim().length > 0);
+  if (!hasContent) return null;
+  const looksLikeYaml = contentLines.some((l) => /[:{\[]/.test(l));
+  if (!looksLikeYaml) return null;
+  const content = contentLines.join("\n");
+  return {
+    node: createHtmlBlock(`<!-- frontmatter
+${content}
+-->`),
+    nextLine: j
+  };
+}
+function tryDetail(lines, i, end, opts) {
+  const line = lines[i];
+  const openMatch = RE_DETAIL_OPEN.exec(line);
+  if (!openMatch) return null;
+  const isOpen = openMatch[1] === "-";
+  const summary = openMatch[2].trim();
+  const contentLines = [];
+  let j = i + 1;
+  while (j < end) {
+    if (RE_DETAIL_CLOSE.test(lines[j])) {
+      j++;
+      break;
+    }
+    contentLines.push(lines[j]);
+    j++;
+  }
+  const children = parseBlockLines(contentLines, 0, contentLines.length, opts);
+  const detailSummary = isOpen ? summary : summary;
+  return {
+    node: createDetails(detailSummary, children),
+    nextLine: j
+  };
+}
+function tryFootnoteDefinition(lines, i, end, opts) {
+  const line = lines[i];
+  const match = RE_FOOTNOTE_DEF.exec(line);
+  if (!match) return null;
+  const identifier = match[1];
+  const firstLineContent = match[2];
+  const contentLines = [firstLineContent];
+  let j = i + 1;
+  while (j < end) {
+    const current = lines[j];
+    if (isBlank(current)) {
+      if (j + 1 < end && /^(?: {2,}|\t)/.test(lines[j + 1])) {
+        contentLines.push("");
+        j++;
+        continue;
+      }
+      break;
+    }
+    if (/^(?: {2,}|\t)/.test(current)) {
+      contentLines.push(current.replace(/^(?: {2,}|\t)/, ""));
+      j++;
+      continue;
+    }
+    break;
+  }
+  const children = parseBlockLines(contentLines, 0, contentLines.length, opts);
+  return {
+    node: createFootnoteDefinition(identifier, identifier, children),
+    nextLine: j
+  };
+}
+function decodeInfoString(str) {
+  let result = str.replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g, "$1");
+  if (result.includes("&")) {
+    result = result.replace(/&(?:#x([0-9a-fA-F]{1,6})|#([0-9]{1,7})|([a-zA-Z][a-zA-Z0-9]{1,31}));/g, (match, hex, dec, name) => {
+      if (hex) return String.fromCodePoint(parseInt(hex, 16) || 65533);
+      if (dec) return String.fromCodePoint(parseInt(dec, 10) || 65533);
+      const entities = { amp: "&", lt: "<", gt: ">", quot: '"', ouml: "\xF6", uuml: "\xFC", auml: "\xE4" };
+      return entities[name] ?? match;
+    });
+  }
+  return result;
+}
+
+// src/incremental.ts
+import { createDocument as createDocument2 } from "@pre-markdown/core";
+function fnv1a(str) {
+  let hash = 2166136261 | 0;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = hash * 16777619 | 0;
+  }
+  return hash >>> 0;
+}
+function combineHashes(hashes, from, to) {
+  let h = 2166136261 | 0;
+  for (let i = from; i < to; i++) {
+    h ^= hashes[i];
+    h = h * 16777619 | 0;
+  }
+  return h >>> 0;
+}
+var LRUBlockCache = class {
+  map = /* @__PURE__ */ new Map();
+  capacity;
+  constructor(capacity = 256) {
+    this.capacity = capacity;
+  }
+  get(fingerprint) {
+    const node = this.map.get(fingerprint);
+    if (node !== void 0) {
+      this.map.delete(fingerprint);
+      this.map.set(fingerprint, node);
+    }
+    return node;
+  }
+  set(fingerprint, node) {
+    if (this.map.has(fingerprint)) {
+      this.map.delete(fingerprint);
+    }
+    this.map.set(fingerprint, node);
+    if (this.map.size > this.capacity) {
+      const oldest = this.map.keys().next().value;
+      this.map.delete(oldest);
+    }
+  }
+  /** Bulk-populate cache from an array of fingerprint→node pairs */
+  populate(metas, nodes) {
+    for (let i = 0; i < metas.length; i++) {
+      this.set(metas[i].fingerprint, nodes[i]);
+    }
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+var IncrementalParser = class {
+  lines = [];
+  lineHashes = [];
+  document;
+  options;
+  eventBus = null;
+  /** Per-block metadata tracking source line ranges and fingerprints */
+  blockMetas = [];
+  /** LRU cache: block fingerprint → previously parsed BlockNode subtree */
+  blockCache = new LRUBlockCache(256);
+  constructor(initialText = "", options, eventBus) {
+    this.options = {
+      gfmTables: true,
+      mathBlocks: true,
+      containers: true,
+      toc: true,
+      footnotes: true,
+      lazyInline: false,
+      ...options
+    };
+    this.eventBus = eventBus ?? null;
+    this.lines = initialText.split("\n");
+    this.lineHashes = this.lines.map(fnv1a);
+    this.document = parseBlocks(initialText, this.options);
+    this.buildBlockMetas();
+  }
+  /** Get current document AST */
+  getDocument() {
+    return this.document;
+  }
+  /** Get current source text */
+  getText() {
+    return this.lines.join("\n");
+  }
+  /** Get current lines */
+  getLines() {
+    return this.lines;
+  }
+  /** Get current line hashes (FNV-1a) */
+  getLineHashes() {
+    return this.lineHashes;
+  }
+  /** Get block metadata (for testing/debugging) */
+  getBlockMetas() {
+    return this.blockMetas;
+  }
+  /**
+   * Apply an edit and incrementally reparse.
+   */
+  applyEdit(edit) {
+    const startTime = performance.now();
+    const newLines = edit.newText.split("\n");
+    const newHashes = newLines.map(fnv1a);
+    const deletedLineCount = edit.toLine - edit.fromLine;
+    const insertedLineCount = newLines.length;
+    const lineDelta = insertedLineCount - deletedLineCount;
+    this.lines.splice(edit.fromLine, deletedLineCount, ...newLines);
+    this.lineHashes.splice(edit.fromLine, deletedLineCount, ...newHashes);
+    const { blockStart, blockEnd } = this.findAffectedBlockRangeFromMetas(
+      edit.fromLine,
+      edit.toLine,
+      lineDelta
+    );
+    const reparseFrom = blockStart < this.blockMetas.length ? this.blockMetas[blockStart].startLine : this.lines.length;
+    let reparseTo;
+    if (blockEnd < this.blockMetas.length) {
+      reparseTo = this.blockMetas[blockEnd].startLine + lineDelta;
+    } else {
+      reparseTo = this.lines.length;
+    }
+    reparseTo = Math.min(reparseTo, this.lines.length);
+    const reparseFromClamped = Math.max(0, Math.min(reparseFrom, this.lines.length));
+    const linesToReparse = this.lines.slice(reparseFromClamped, reparseTo);
+    const newBlocks = linesToReparse.length > 0 ? parseBlockLines(linesToReparse, 0, linesToReparse.length, this.options) : [];
+    const oldBlockCount = blockEnd - blockStart;
+    const oldChildren = this.document.children;
+    let cacheHits = 0;
+    if (newBlocks.length > 0) {
+      let newLineAcc = reparseFromClamped;
+      for (let bi = 0; bi < newBlocks.length; bi++) {
+        const block = newBlocks[bi];
+        const blockLineCount = this.estimateBlockLineCount(block);
+        const blockEndLine = Math.min(newLineAcc + blockLineCount, this.lines.length);
+        const fp = combineHashes(this.lineHashes, newLineAcc, blockEndLine);
+        const cached = this.blockCache.get(fp);
+        if (cached && cached.type === block.type) {
+          newBlocks[bi] = cached;
+          cacheHits++;
+        }
+        newLineAcc = blockEndLine;
+      }
+    }
+    const beforeBlocks = oldChildren.slice(0, blockStart);
+    const afterBlocks = oldChildren.slice(blockEnd);
+    const updatedChildren = [
+      ...beforeBlocks,
+      ...newBlocks,
+      ...afterBlocks
+    ];
+    const reusedBlockCount = beforeBlocks.length + afterBlocks.length + cacheHits;
+    this.document = createDocument2(updatedChildren);
+    this.buildBlockMetas();
+    const duration = performance.now() - startTime;
+    if (this.eventBus) {
+      this.eventBus.emit("content:change", {
+        text: this.getText(),
+        from: edit.fromLine,
+        to: edit.toLine,
+        inserted: edit.newText
+      });
+      this.eventBus.emit("parse:done", {
+        documentId: this.document.id ?? 0,
+        duration
+      });
+    }
+    return {
+      document: this.document,
+      affectedRange: { from: reparseFromClamped, to: reparseTo },
+      newBlockCount: newBlocks.length,
+      oldBlockCount,
+      reusedBlockCount,
+      duration
+    };
+  }
+  /**
+   * Full reparse — used when edits are too complex for incremental update.
+   */
+  fullReparse() {
+    const startTime = performance.now();
+    const text = this.lines.join("\n");
+    this.lineHashes = this.lines.map(fnv1a);
+    this.document = parseBlocks(text, this.options);
+    this.buildBlockMetas();
+    const duration = performance.now() - startTime;
+    if (this.eventBus) {
+      this.eventBus.emit("parse:done", {
+        documentId: this.document.id ?? 0,
+        duration
+      });
+    }
+    return this.document;
+  }
+  /**
+   * Build block metadata array from current document + lines.
+   * Assigns each block its source line range and fingerprint.
+   */
+  buildBlockMetas() {
+    const children = this.document.children;
+    const metas = new Array(children.length);
+    let lineAcc = 0;
+    for (let i = 0; i < children.length; i++) {
+      const lc = this.estimateBlockLineCount(children[i]);
+      const startLine = lineAcc;
+      const endLine = Math.min(lineAcc + lc, this.lines.length);
+      const fingerprint = combineHashes(this.lineHashes, startLine, endLine);
+      metas[i] = { startLine, endLine, fingerprint };
+      this.blockCache.set(fingerprint, children[i]);
+      lineAcc = endLine;
+    }
+    this.blockMetas = metas;
+  }
+  /**
+   * Find affected block range using block metas for precise mapping.
+   * Returns [blockStart, blockEnd) — the half-open range of blocks to replace.
+   */
+  findAffectedBlockRangeFromMetas(editFromLine, editToLine, _lineDelta) {
+    const metas = this.blockMetas;
+    if (metas.length === 0) {
+      return { blockStart: 0, blockEnd: 0 };
+    }
+    let blockStart = 0;
+    {
+      let lo = 0, hi = metas.length - 1;
+      while (lo <= hi) {
+        const mid = lo + hi >>> 1;
+        if (metas[mid].endLine <= editFromLine) {
+          lo = mid + 1;
+        } else {
+          blockStart = mid;
+          hi = mid - 1;
+        }
+      }
+    }
+    blockStart = Math.max(0, blockStart - 1);
+    let blockEnd = metas.length;
+    {
+      let lo = blockStart, hi = metas.length - 1;
+      while (lo <= hi) {
+        const mid = lo + hi >>> 1;
+        if (metas[mid].startLine < editToLine) {
+          lo = mid + 1;
+        } else {
+          blockEnd = mid;
+          hi = mid - 1;
+        }
+      }
+    }
+    blockEnd = Math.min(metas.length, blockEnd + 1);
+    return { blockStart, blockEnd };
+  }
+  /**
+   * Estimate how many source lines a block node spans.
+   * This is a heuristic — precise tracking would require SourceLocation data.
+   */
+  estimateBlockLineCount(node) {
+    switch (node.type) {
+      case "heading":
+        return 2;
+      // heading + blank line
+      case "paragraph": {
+        if (node._raw) {
+          const nlCount = node._raw.split("\n").length;
+          return nlCount + 1;
+        }
+        let textLen = 0;
+        for (const child of node.children) {
+          if (child.type === "text") textLen += child.value.length;
+          if (child.type === "softBreak") textLen += 1;
+        }
+        return Math.max(2, Math.ceil(textLen / 80) + 1);
+      }
+      case "codeBlock": {
+        const lineCount = node.value.split("\n").length;
+        return lineCount + 3;
+      }
+      case "blockquote": {
+        let count = 0;
+        for (const child of node.children) {
+          count += this.estimateBlockLineCount(child);
+        }
+        return Math.max(2, count + 1);
+      }
+      case "list": {
+        let count = 0;
+        for (const item of node.children) {
+          count += this.estimateBlockLineCount(item);
+        }
+        return count + 1;
+      }
+      case "listItem": {
+        let count = 1;
+        for (const child of node.children) {
+          count += this.estimateBlockLineCount(child) - 1;
+        }
+        return Math.max(1, count);
+      }
+      case "table": {
+        return node.children.length + 2;
+      }
+      case "thematicBreak":
+        return 2;
+      case "mathBlock": {
+        const lines = node.value.split("\n").length;
+        return lines + 3;
+      }
+      case "container": {
+        let count = 2;
+        for (const child of node.children) {
+          count += this.estimateBlockLineCount(child);
+        }
+        return count + 1;
+      }
+      case "details": {
+        let count = 2;
+        for (const child of node.children) {
+          count += this.estimateBlockLineCount(child);
+        }
+        return count + 1;
+      }
+      case "footnoteDefinition": {
+        let count = 1;
+        for (const child of node.children) {
+          count += this.estimateBlockLineCount(child);
+        }
+        return count + 1;
+      }
+      default:
+        return 2;
+    }
+  }
+};
+
+// src/index.ts
+function parse(input, options) {
+  return parseBlocks(input, options);
+}
+export {
+  IncrementalParser,
+  parse,
+  parseBlockLines,
+  parseBlocks,
+  parseInline
+};
+//# sourceMappingURL=index.js.map