@wdprlib/parser 5.3.0 → 5.4.0

package/dist/index.cjs

@@ -82,8 +82,8 @@ module.exports = __toCommonJS(exports_src);
 
 // packages/parser/src/build-info.generated.ts
 var buildInfo = Object.freeze({
-  version: "5.3.0",
-  sha: "b71b84c705e05717f5ea12fd89684a91b669dbff",
+  version: "5.4.0",
+  sha: "5e221ddeccc585e64dd1a2eb49b14817c3c1be5d",
   dirty: false
 });
 
@@ -272,13 +272,13 @@ function isValidAnchorNameChar(code) {
 }
 
 // packages/parser/src/lexer/quoted-string.ts
-function scanQuotedString(state) {
+function scanQuotedString(state, end = state.source.length) {
   let quoted = advance(state);
-  while (!isAtEnd(state) && current(state) !== '"' && current(state) !== `
+  while (state.pos < end && current(state) !== '"' && current(state) !== `
 `) {
     quoted += advance(state);
   }
-  if (current(state) === '"') {
+  if (state.pos < end && current(state) === '"') {
     quoted += advance(state);
   }
   return quoted;
@@ -363,6 +363,26 @@ function isCompactPlainTextBoundary(code) {
   }
 }
 
+// packages/parser/src/lexer/url-schemes.ts
+var URL_SCHEME_NAMES = new Set([
+  "http",
+  "https",
+  "ftp",
+  "gopher",
+  "news",
+  "mailto",
+  "mms"
+]);
+var TRAILING_URL_SCHEME = /(?:^|[^A-Za-z0-9])(https?|ftp|gopher|news|mailto|mms)$/;
+var URL_SCHEME_PREFIX = /^(?:(?:https?|ftp|gopher|news|mms):\/\/|mailto:)/;
+var URL_PATTERN = /^(?:(?:https?|ftp|gopher|news|mms):\/\/|mailto:)(?:[^ \\/"']*\/)*[^ \t\n\\/"']*[A-Za-z%0-9/?=&~_]/;
+function startsWithUrlScheme(src, pos) {
+  return URL_SCHEME_PREFIX.test(src.slice(pos, pos + 10));
+}
+function startsWithUrl(src, pos) {
+  return URL_PATTERN.test(src.slice(pos, pos + 2048));
+}
+
 // packages/parser/src/lexer/syntax-actions.ts
 function scanSimpleSyntaxToken(src, pos, isLineStart) {
   switch (src[pos]) {
@@ -399,7 +419,7 @@ function scanSimpleSyntaxToken(src, pos, isLineStart) {
   }
 }
 function scanStarToken(src, pos, isLineStart) {
-  if (src[pos + 1] === "*") {
+  if (src[pos + 1] === "*" && !startsWithUrl(src, pos + 2)) {
     return token("BOLD_MARKER", "**");
   }
   return isLineStart ? token("LIST_BULLET", "*") : token("STAR", "*");
@@ -585,7 +605,13 @@ function scanTextToken(src, pos) {
   return token3("TEXT", char);
 }
 function scanCompactTextToken(src, pos) {
-  const end = findCompactPlainTextRunEnd(src, pos);
+  let end = findCompactPlainTextRunEnd(src, pos);
+  if (end > pos && src[end] === ":") {
+    const match = TRAILING_URL_SCHEME.exec(src.slice(pos, end));
+    if (match) {
+      end -= match[1].length;
+    }
+  }
   return end > pos ? runToken3(src, pos, end, "TEXT") : null;
 }
 function token3(type, value) {
@@ -631,6 +657,8 @@ class Lexer {
   splitBlockClosePositions = new Set;
   lastNonWhitespaceType = null;
   blockOpenerDepth = 0;
+  rawTagBounds = null;
+  rawClosesExhausted = false;
   constructor(source, options = {}) {
     this.options = {
       trackPositions: options.trackPositions ?? true,
@@ -651,8 +679,8 @@ class Lexer {
   current() {
     return current(this.state);
   }
-  findInvalidAnchorNameEnd() {
-    return findInvalidAnchorNameEnd(this.state.source, this.state.pos);
+  findInvalidAnchorNameEnd(source) {
+    return findInvalidAnchorNameEnd(source, this.state.pos);
   }
   advance(n = 1) {
     return advance(this.state, n);
@@ -664,6 +692,18 @@ class Lexer {
     this.state.tokens.push(createLexerToken(this.state, type, value, this.options.trackPositions));
     this.lastNonWhitespaceType = updateLastNonWhitespaceType(this.lastNonWhitespaceType, type);
     this.blockOpenerDepth = nextBlockOpenerDepth(this.blockOpenerDepth, type);
+    if (this.rawTagBounds === null && !this.rawClosesExhausted && (value.toLowerCase() === "button" || value.toLowerCase() === "social") && this.state.tokens.at(-2)?.type === "BLOCK_OPEN" && /\s/.test(this.current())) {
+      const close = this.state.source.indexOf("]]", this.state.pos);
+      if (close < 0) {
+        this.rawClosesExhausted = true;
+      } else {
+        this.rawTagBounds = {
+          source: this.state.source.slice(0, close),
+          close,
+          outerDepth: this.blockOpenerDepth - 1
+        };
+      }
+    }
   }
   emitTokenAction(action) {
     advanceByToken(this.state, action.type, action.length, action.value);
@@ -681,7 +721,14 @@ class Lexer {
   scanToken() {
     const char = this.current();
     const isLineStart = isSyntaxLineStart(this.state);
-    const src = this.state.source;
+    const bounds = this.rawTagBounds;
+    const src = bounds?.source ?? this.state.source;
+    if (bounds && this.state.pos === bounds.close) {
+      this.emitTokenAction({ type: "BLOCK_CLOSE", value: "]]", length: 2 });
+      this.blockOpenerDepth = bounds.outerDepth;
+      this.rawTagBounds = null;
+      return;
+    }
     const spacingAction = scanSpacingToken(src, this.state.pos);
     if (spacingAction) {
       this.emitTokenAction(limitBlockquotePrefixSpace(spacingAction, this.state.tokens.at(-1)));
@@ -694,7 +741,7 @@ class Lexer {
       lineStart: isLineStart,
       physicalLineStart: this.state.lineStart,
       splitBlockClose: this.splitBlockClosePositions.has(this.state.pos),
-      findInvalidAnchorNameEnd: () => this.findInvalidAnchorNameEnd()
+      findInvalidAnchorNameEnd: () => this.findInvalidAnchorNameEnd(src)
     });
     if (punctuation.handled) {
       if (punctuation.clearSplitBlockCloseAt !== undefined) {
@@ -709,7 +756,7 @@ class Lexer {
     if (char === '"') {
       const lastNonWs = this.lastNonWhitespaceTokenType();
       if (this.blockOpenerDepth > 0 && lastNonWs === "EQUALS") {
-        this.addToken("QUOTED_STRING", scanQuotedString(this.state));
+        this.addToken("QUOTED_STRING", scanQuotedString(this.state, src.length));
         return;
       }
       this.advance();
@@ -897,7 +944,7 @@ function parseBlockItem(ctx) {
     }
   }
   const fallback = ctx.blockFallbackRule.parse(ctx);
-  if (fallback.success && fallback.elements.length > 0) {
+  if (fallback.success) {
     return { elements: fallback.elements, consumed: fallback.consumed };
   }
   return { elements: [], consumed: 1 };
@@ -945,7 +992,8 @@ function parseBlocksUntil(ctx, closeCondition, options) {
     blockCtx.pos = pos;
     blockCtx.scope = blockScope;
     const result = parseBlockItem(blockCtx);
-    elements.push(...result.elements);
+    for (const element of result.elements)
+      elements.push(element);
     consumed += result.consumed;
     pos += result.consumed;
   }
@@ -972,6 +1020,42 @@ function getExcludedBlockRules(blockRules, excluded) {
   byExcluded.set(excluded, filtered);
   return filtered;
 }
+// packages/parser/src/parser/rules/inline/parsing/automatic-line-break.ts
+var origins = new WeakMap;
+function createAutomaticLineBreak(token5) {
+  const element = { element: "line-break" };
+  origins.set(element, token5);
+  return element;
+}
+function precedingSingleNewline(ctx) {
+  let pos = ctx.pos - 1;
+  while (ctx.tokens[pos]?.type === "WHITESPACE")
+    pos--;
+  const newline = ctx.tokens[pos];
+  if (newline?.type !== "NEWLINE")
+    return;
+  pos--;
+  while (ctx.tokens[pos]?.type === "WHITESPACE")
+    pos--;
+  if (ctx.tokens[pos]?.type === "NEWLINE")
+    return;
+  return newline;
+}
+function stripAutomaticLineBreak(elements, token5) {
+  if (!token5)
+    return;
+  let index = elements.length - 1;
+  while (index >= 0) {
+    const element2 = elements[index];
+    if (element2?.element !== "text" || !/^[ \t]*$/.test(element2.data))
+      break;
+    index--;
+  }
+  const element = elements[index];
+  if (element && origins.get(element) === token5)
+    elements.length = index;
+}
+
 // packages/parser/src/parser/rules/inline/parsing/rules.ts
 function canApplyInlineRule(rule, token5) {
   if (rule.startTokens.length === 0) {
@@ -994,18 +1078,479 @@ function getCandidateInlineRules(inlineRules, tokenType) {
   byType.set(tokenType, candidates);
   return candidates;
 }
+// packages/parser/src/parser/rules/inline/parsing/raw-tag.ts
+var unclosedRanges = new WeakMap;
+function findRawTagClose(tokens, start, end) {
+  const unclosed = unclosedRanges.get(tokens);
+  if (unclosed && start >= unclosed.start && end <= unclosed.end)
+    return null;
+  for (let close = start;close < end; close++) {
+    if (tokens[close]?.type === "BLOCK_CLOSE")
+      return close;
+    if (!tokens[close] || tokens[close]?.type === "EOF")
+      break;
+  }
+  unclosedRanges.set(tokens, { start, end });
+  return null;
+}
+
+// packages/parser/src/parser/rules/inline/button/attributes.ts
+function parseButtonAttributes(source) {
+  const sections = source.trim().split('="');
+  const attrs = {};
+  let key = sections[0].trim();
+  for (const section of sections.slice(1)) {
+    const quote = section.lastIndexOf('"');
+    if (quote < 0)
+      continue;
+    if (key === "text" || key === "class" || key === "style") {
+      attrs[key] = section.slice(0, quote).replace(/\\([\s\S]|$)/g, (_match, char) => char === "0" ? "\x00" : char);
+    }
+    key = section.slice(quote + 1).trim();
+  }
+  return attrs;
+}
+
+// packages/parser/src/parser/rules/inline/button/syntax.ts
+function parseButtonSyntax(ctx, start, end) {
+  const tokens = ctx.tokens;
+  if (tokens[start]?.type !== "BLOCK_OPEN" || tokens[start + 1]?.value.toLowerCase() !== "button")
+    return null;
+  let pos = start + 2;
+  const skipSpace = () => {
+    const before = pos;
+    while (pos < end && /^\s+$/.test(tokens[pos]?.value ?? ""))
+      pos++;
+    return pos > before;
+  };
+  if (!skipSpace())
+    return null;
+  let action = "";
+  while (pos < end && tokens[pos]?.type !== "BLOCK_CLOSE" && !/^\s+$/.test(tokens[pos]?.value ?? "")) {
+    const part = tokens[pos]?.value ?? "";
+    if (!/^[a-z0-9_-]+$/i.test(part))
+      return null;
+    action += part;
+    pos++;
+  }
+  if (!action)
+    return null;
+  action = action.replaceAll("_", "-");
+  skipSpace();
+  const close = findRawTagClose(tokens, pos, end);
+  if (close === null)
+    return null;
+  const attrs = parseButtonAttributes(tokens.slice(pos, close).map((token5) => token5.value).join(""));
+  const value = (key) => attrs[key] && attrs[key] !== "0" ? attrs[key] : null;
+  const attributes = {};
+  for (const name of ["class", "style"]) {
+    const attr = value(name);
+    if (attr !== null)
+      attributes[name] = attr;
+  }
+  return { data: { action, text: value("text"), attributes }, end: close + 1 };
+}
+
+// packages/parser/src/parser/rules/inline/social/syntax.ts
+var invalidBodies = new WeakMap;
+function parseSocialSyntax(ctx, start, end) {
+  const tokens = ctx.tokens;
+  if (tokens[start]?.type !== "BLOCK_OPEN" || tokens[start + 1]?.value.toLowerCase() !== "social")
+    return null;
+  const bodyStart = start + 2;
+  if (tokens[bodyStart]?.type !== "BLOCK_CLOSE" && !/^\s+$/.test(tokens[bodyStart]?.value ?? ""))
+    return null;
+  const invalid = invalidBodies.get(tokens);
+  if (invalid && bodyStart >= invalid.start && bodyStart <= invalid.bracket)
+    return null;
+  const close = findRawTagClose(tokens, bodyStart, end);
+  if (close === null)
+    return null;
+  for (let pos = bodyStart;pos < close; pos++) {
+    if (tokens[pos].value.includes("]")) {
+      invalidBodies.set(tokens, { start: bodyStart, bracket: pos });
+      return null;
+    }
+  }
+  const body = tokens.slice(bodyStart, close).map((token5) => token5.value).join("");
+  const sites = body.trim() ? body.split(",").map((site) => site.trim().toLowerCase()).filter(Boolean) : null;
+  return { data: { sites }, end: close + 1 };
+}
+
+// packages/parser/src/parser/rules/block/parsing/attributes/names.ts
+function consumeAttributeName(ctx, startPos, startConsumed, startName, options) {
+  if (startName === "_" && isAttributeWordToken(ctx.tokens[startPos])) {
+    startName += ctx.tokens[startPos]?.value ?? "";
+    startPos++;
+    startConsumed++;
+  }
+  return options.strikeHyphens ? consumeRawNameSuffix(ctx, startPos, startConsumed, startName, options.hyphenatedNames) : consumeSafeNameSuffix(ctx, startPos, startConsumed, startName);
+}
+function isAttributeNameToken(token5) {
+  return isAttributeWordToken(token5) || token5?.type === "UNDERSCORE";
+}
+function consumeSafeNameSuffix(ctx, startPos, startConsumed, startName) {
+  let name = startName;
+  let pos = startPos;
+  let consumed = startConsumed;
+  while (isAttributeNameSeparator(ctx.tokens[pos]) && isAttributeWordToken(ctx.tokens[pos + 1])) {
+    name += ctx.tokens[pos]?.value ?? "";
+    pos++;
+    consumed++;
+    name += ctx.tokens[pos]?.value ?? "";
+    pos++;
+    consumed++;
+  }
+  return { name, pos, consumed };
+}
+function consumeRawNameSuffix(ctx, startPos, startConsumed, startName, hyphenatedNames) {
+  let name = startName;
+  let pos = startPos;
+  let consumed = startConsumed;
+  while (isAttributeNameSeparator(ctx.tokens[pos])) {
+    while (isAttributeNameSeparator(ctx.tokens[pos])) {
+      if (hyphenatedNames || ctx.tokens[pos]?.type === "UNDERSCORE") {
+        name += ctx.tokens[pos]?.value ?? "-";
+      }
+      pos++;
+      consumed++;
+    }
+    if (!isAttributeWordToken(ctx.tokens[pos])) {
+      break;
+    }
+    if (hyphenatedNames || name.endsWith("_")) {
+      name += ctx.tokens[pos]?.value ?? "";
+    }
+    pos++;
+    consumed++;
+  }
+  return { name, pos, consumed };
+}
+function isAttributeWordToken(token5) {
+  return token5?.type === "TEXT" || token5?.type === "IDENTIFIER";
+}
+function isAttributeNameSeparator(token5) {
+  return token5?.type === "TEXT" && token5.value === "-" || token5?.type === "STRIKE_MARKER" || token5?.type === "UNDERSCORE";
+}
+
+// packages/parser/src/parser/rules/block/parsing/attributes/values.ts
+function consumeAttributeValue(token5) {
+  if (!token5) {
+    return null;
+  }
+  if (token5.type === "QUOTED_STRING") {
+    return { value: stripQuotes(token5.value) };
+  }
+  if (isAttributeNameToken(token5)) {
+    return { value: token5.value };
+  }
+  return null;
+}
+function stripQuotes(value) {
+  return value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+}
+
+// packages/parser/src/parser/rules/block/parsing/attributes/scanner.ts
+function scanAttributes(ctx, startPos, options) {
+  const attrs = {};
+  let pos = startPos;
+  let consumed = 0;
+  while (pos < ctx.tokens.length) {
+    const token5 = ctx.tokens[pos];
+    if (!token5 || isAttributeTerminator(token5)) {
+      break;
+    }
+    if (token5.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+    if (!isAttributeNameToken(token5)) {
+      pos++;
+      consumed++;
+      continue;
+    }
+    let name = token5.value;
+    pos++;
+    consumed++;
+    const nameResult = consumeAttributeName(ctx, pos, consumed, name, options);
+    pos = nameResult.pos;
+    consumed = nameResult.consumed;
+    name = nameResult.name.toLowerCase();
+    if (ctx.tokens[pos]?.type !== "EQUALS") {
+      attrs[name] = "true";
+      continue;
+    }
+    pos++;
+    consumed++;
+    const valueResult = consumeAttributeValue(ctx.tokens[pos]);
+    if (!valueResult) {
+      continue;
+    }
+    attrs[name] = valueResult.value;
+    pos++;
+    consumed++;
+  }
+  return { attrs, consumed };
+}
+function isAttributeTerminator(token5) {
+  return token5.type === "BLOCK_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF";
+}
+
+// packages/parser/src/parser/rules/block/parsing/attributes/index.ts
+function parseAttributes(ctx, startPos) {
+  const result = scanAttributes(ctx, startPos, { hyphenatedNames: true, strikeHyphens: false });
+  return { attrs: filterUnsafeAttributes(result.attrs), consumed: result.consumed };
+}
+function parseAttributesRaw(ctx, startPos, hyphenatedNames = true) {
+  return scanAttributes(ctx, startPos, { hyphenatedNames, strikeHyphens: true });
+}
+
+// packages/parser/src/parser/rules/inline/date/syntax.ts
+function parseDateSyntax(ctx, start, end) {
+  const tokens = ctx.tokens;
+  if (tokens[start]?.type !== "BLOCK_OPEN" || tokens[start + 1]?.value !== "date")
+    return null;
+  let pos = start + 2;
+  const skipSpace = () => {
+    const before = pos;
+    while (pos < end && /^(?:\s+)$/.test(tokens[pos]?.value ?? ""))
+      pos++;
+    return pos > before;
+  };
+  if (!skipSpace())
+    return null;
+  const value = tokens[pos]?.value ?? "";
+  if (pos >= end || !/^\d+$/.test(value))
+    return null;
+  const timestamp = Number(value);
+  if (!Number.isSafeInteger(timestamp) || timestamp > 8640000000000)
+    return null;
+  pos++;
+  const separator = skipSpace();
+  if (tokens[pos]?.type !== "BLOCK_CLOSE" && !separator)
+    return null;
+  let close = pos;
+  for (;close < end; close++) {
+    const token5 = tokens[close];
+    if (!token5 || token5.type === "EOF" || token5.type === "BLOCK_OPEN" || /[\r\n]/.test(token5.value))
+      return null;
+    if (token5.type === "BLOCK_CLOSE")
+      break;
+  }
+  if (close >= end)
+    return null;
+  const attributes = parseAttributesRaw(ctx, pos).attrs;
+  const format = attributes.format || null;
+  return {
+    data: {
+      value: { timestamp, timezone: "UTC" },
+      format,
+      hover: format?.split("|").slice(1).includes("agohover") ?? false
+    },
+    end: close + 1
+  };
+}
+
+// packages/parser/src/parser/rules/inline/email/scan.ts
+function isDomainChar(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 45;
+}
+function isLocalChar(code) {
+  return isDomainChar(code) || code === 95;
+}
+function scanEmail(source, start, commentEnd) {
+  const comments = [];
+  let pos = start;
+  const skipComments = () => {
+    let end2 = commentEnd(pos);
+    while (end2 > pos) {
+      comments.push({ start: pos, end: end2 });
+      pos = end2;
+      end2 = commentEnd(pos);
+    }
+  };
+  let localPart = false;
+  while (pos < source.length) {
+    skipComments();
+    if (isLocalChar(source.charCodeAt(pos))) {
+      localPart = true;
+      pos++;
+    } else if (source[pos] === "." && localPart) {
+      localPart = false;
+      pos++;
+    } else
+      break;
+  }
+  const localEnd = pos;
+  if (!localPart || source[pos] !== "@")
+    return { localEnd, comments };
+  pos++;
+  let domainPart = false;
+  let dots = 0;
+  let end = -1;
+  while (pos < source.length) {
+    skipComments();
+    if (isDomainChar(source.charCodeAt(pos))) {
+      domainPart = true;
+      pos++;
+      if (dots > 0)
+        end = pos;
+    } else if (source[pos] === "." && domainPart) {
+      domainPart = false;
+      dots++;
+      pos++;
+    } else
+      break;
+  }
+  if (end === -1)
+    return { localEnd, comments };
+  const parts = [];
+  let copied = start;
+  for (const comment of comments) {
+    if (comment.start >= end)
+      break;
+    parts.push(source.slice(copied, comment.start));
+    copied = comment.end;
+  }
+  parts.push(source.slice(copied, end));
+  return { end, address: parts.join(""), localEnd, comments };
+}
+
+// packages/parser/src/parser/rules/inline/email/candidates.ts
+var caches = new WeakMap;
+var EMAIL_START_TOKENS = [
+  "TEXT",
+  "IDENTIFIER",
+  "UNDERSCORE",
+  "UNDERLINE_MARKER",
+  "STRIKE_MARKER"
+];
+function getCache(tokens) {
+  let cache = caches.get(tokens);
+  if (cache)
+    return cache;
+  const offsets = [0];
+  const values = [];
+  for (const token5 of tokens) {
+    values.push(token5.value);
+    offsets.push(offsets.at(-1) + token5.value.length);
+  }
+  cache = {
+    source: values.join(""),
+    offsets,
+    candidates: new Map,
+    commentEnds: new Map,
+    unclosedComment: Infinity
+  };
+  caches.set(tokens, cache);
+  return cache;
+}
+function commentEnd(cache, pos) {
+  const opener = cache.source[pos] === `
+` ? pos + 1 : pos;
+  if (!cache.source.startsWith("[!--", opener))
+    return pos;
+  const cached = cache.commentEnds.get(pos);
+  if (cached !== undefined)
+    return cached;
+  const close = opener >= cache.unclosedComment ? -1 : cache.source.indexOf("--]", opener + 4);
+  if (close === -1)
+    cache.unclosedComment = Math.min(cache.unclosedComment, opener);
+  const end = close === -1 ? pos : close + 3;
+  cache.commentEnds.set(pos, end);
+  return end;
+}
+function getEmailCandidate(tokens, index) {
+  const token5 = tokens[index];
+  if (!token5 || !EMAIL_START_TOKENS.includes(token5.type))
+    return null;
+  const cache = getCache(tokens);
+  if (cache.candidates.has(index))
+    return cache.candidates.get(index);
+  const value = tokens[index]?.value ?? "";
+  let suffix = value.length;
+  while (suffix > 0 && (isLocalChar(value.charCodeAt(suffix - 1)) || value[suffix - 1] === "."))
+    suffix--;
+  const doubled = value.lastIndexOf("..");
+  if (doubled >= suffix)
+    suffix = doubled + 2;
+  while (value[suffix] === ".")
+    suffix++;
+  if (suffix >= value.length || !isLocalChar(value.charCodeAt(suffix))) {
+    cache.candidates.set(index, null);
+    return null;
+  }
+  const start = cache.offsets[index] + suffix;
+  const scanned = scanEmail(cache.source, start, (pos) => commentEnd(cache, pos));
+  if (scanned.end === undefined) {
+    cache.candidates.set(index, null);
+    let comment = 0;
+    for (let i = index + 1;i < tokens.length && cache.offsets[i + 1] <= scanned.localEnd; i++) {
+      const offset = cache.offsets[i];
+      while (scanned.comments[comment] && scanned.comments[comment].end <= offset)
+        comment++;
+      const region = scanned.comments[comment];
+      if (!region || offset < region.start)
+        cache.candidates.set(i, null);
+    }
+    return null;
+  }
+  let endToken = index;
+  while (cache.offsets[endToken + 1] < scanned.end)
+    endToken++;
+  const candidate = { start, end: scanned.end, endToken, address: scanned.address };
+  cache.candidates.set(index, candidate);
+  return candidate;
+}
+function getEmailGroup(tokens, index, limit) {
+  const first = getEmailCandidate(tokens, index);
+  if (!first || first.endToken >= limit)
+    return null;
+  const candidates = [first];
+  let last = first;
+  while (last.endToken > index) {
+    const next = getEmailCandidate(tokens, last.endToken);
+    if (!next || next.start < last.end || next.endToken >= limit)
+      break;
+    candidates.push(next);
+    last = next;
+  }
+  const cache = getCache(tokens);
+  return {
+    candidates,
+    source: cache.source,
+    start: cache.offsets[index],
+    end: cache.offsets[last.endToken + 1],
+    endToken: last.endToken + 1
+  };
+}
+function emailRegionEnd(tokens, index, limit) {
+  return getEmailGroup(tokens, index, limit)?.endToken ?? index;
+}
+
 // packages/parser/src/parser/rules/inline/raw/end.ts
+var unclosedAngleRanges = new WeakMap;
 function rawRegionEnd(tokens, start, end) {
   const type = tokens[start]?.type;
   const close = type === "RAW_OPEN" ? "RAW_OPEN" : type === "RAW_BLOCK_OPEN" ? "RAW_BLOCK_CLOSE" : null;
   if (!close)
     return start;
+  const cached = type === "RAW_BLOCK_OPEN" ? unclosedAngleRanges.get(tokens) : undefined;
+  if (cached && start >= cached.start && start < cached.end && (cached.lineEnd || end <= cached.end)) {
+    return start;
+  }
   for (let pos = start + 1;pos < end; pos++) {
-    if (tokens[pos]?.type === "NEWLINE" || tokens[pos]?.type === "EOF")
-      break;
+    if (tokens[pos]?.type === "NEWLINE" || tokens[pos]?.type === "EOF") {
+      if (type === "RAW_BLOCK_OPEN")
+        unclosedAngleRanges.set(tokens, { start, end: pos, lineEnd: true });
+      return start;
+    }
     if (tokens[pos]?.type === close)
       return pos + 1;
   }
+  if (type === "RAW_BLOCK_OPEN")
+    unclosedAngleRanges.set(tokens, { start, end, lineEnd: false });
   return start;
 }
 function protectedInlineRegionEnd(tokens, start, end) {
@@ -1024,7 +1569,7 @@ var MIN_INLINE_TEXT_RUN_LENGTH = 32;
 var MIN_INLINE_TEXT_RUN_DOCUMENT_TOKENS = 1e5;
 function collectLongPlainTextRun(ctx, startPos, endType) {
   const firstToken = ctx.tokens[startPos];
-  if (firstToken?.type === "TEXT" && firstToken.value.length >= MIN_INLINE_TEXT_RUN_LENGTH && firstToken.value !== "(") {
+  if (!getEmailCandidate(ctx.tokens, startPos) && firstToken?.type === "TEXT" && firstToken.value.length >= MIN_INLINE_TEXT_RUN_LENGTH && firstToken.value !== "(") {
     return { value: firstToken.value, consumed: 1 };
   }
   let pos = startPos;
@@ -1046,10 +1591,10 @@ function collectLongPlainTextRun(ctx, startPos, endType) {
 }
 function isPlainTextRunToken(ctx, pos) {
   const token5 = ctx.tokens[pos];
-  if (!token5)
+  if (!token5 || getEmailCandidate(ctx.tokens, pos))
     return false;
   if (token5.type === "IDENTIFIER") {
-    return true;
+    return !(URL_SCHEME_NAMES.has(token5.value) && ctx.tokens[pos + 1]?.type === "COLON");
   }
   if (token5.type === "WHITESPACE") {
     const next = ctx.tokens[pos + 1];
@@ -1198,6 +1743,10 @@ var BLOCK_START_TOKENS = [
   "HEADING_MARKER",
   "HR_MARKER",
   "TABLE_MARKER",
+  "TABLE_HEADER",
+  "TABLE_LEFT",
+  "TABLE_CENTER",
+  "TABLE_RIGHT",
   "COLON",
   "BLOCK_OPEN",
   "BLOCK_END_OPEN",
@@ -1275,14 +1824,727 @@ var INDENT_ACCEPTING_BLOCK_NAMES = new Set([
   "tabs"
 ]);
 
-// packages/parser/src/parser/rules/inline/parsing/block-boundary.ts
-function isExcludedBlockToken(ctx, tokenPos) {
-  const excluded = ctx.scope.excludedBlockNames;
-  if (!excluded?.size)
-    return false;
-  const token5 = ctx.tokens[tokenPos];
-  if (token5?.type !== "BLOCK_OPEN" && token5?.type !== "BLOCK_END_OPEN")
-    return false;
+// packages/parser/src/parser/rules/block/code/open.ts
+var attributeRanges = new WeakMap;
+function findAttributesEnd(tokens, start) {
+  const cached = attributeRanges.get(tokens);
+  if (cached && start >= cached.start && start <= cached.end)
+    return cached.end;
+  let end = start;
+  while (end < tokens.length) {
+    const type = tokens[end]?.type;
+    if (type === "BLOCK_CLOSE" || type === "NEWLINE" || type === "EOF")
+      break;
+    end++;
+  }
+  attributeRanges.set(tokens, { start, end });
+  return end;
+}
+function findCodeOpen(tokens, start) {
+  const name = tokens[start + 1];
+  if (tokens[start]?.type !== "BLOCK_OPEN" || name?.type !== "IDENTIFIER" && name?.type !== "TEXT" || name.value.toLowerCase() !== "code" || tokens[start + 2]?.type === "UNDERSCORE")
+    return null;
+  const attributesEnd = findAttributesEnd(tokens, start + 2);
+  const repaired = tokens[attributesEnd]?.type !== "BLOCK_CLOSE";
+  const last = tokens[attributesEnd - 1];
+  if (repaired && (last?.type !== "QUOTED_STRING" || !last.value.includes("]]")))
+    return null;
+  let bodyStart = attributesEnd + (repaired ? 0 : 1);
+  if (tokens[bodyStart]?.type === "NEWLINE")
+    bodyStart++;
+  return {
+    attributesEnd,
+    bodyStart,
+    repaired,
+    closingSwallowed: repaired && last.value.includes("[[/code]]")
+  };
+}
+
+// packages/parser/src/parser/rules/block/code/boundary.ts
+var caches2 = new WeakMap;
+function codeCloseEnd(tokens, start) {
+  if (tokens[start]?.type !== "BLOCK_END_OPEN" || tokens[start + 1]?.value.toLowerCase() !== "code")
+    return start;
+  let end = start + 2;
+  while (tokens[end]?.type === "WHITESPACE")
+    end++;
+  return tokens[end]?.type === "BLOCK_CLOSE" ? end + 1 : start;
+}
+function nestedCodeBodyStart(tokens, start) {
+  if (tokens[start]?.type !== "BLOCK_OPEN" || tokens[start + 1]?.value.toLowerCase() !== "code")
+    return start;
+  for (let pos = start + 2;pos < tokens.length; pos++) {
+    const type = tokens[pos]?.type;
+    if (type === "NEWLINE" || type === "EOF" || type === "BLOCK_OPEN")
+      return start;
+    if (type === "BLOCK_CLOSE") {
+      const open = findCodeOpen(tokens, start);
+      return open && !open.repaired ? open.bodyStart : start;
+    }
+  }
+  return start;
+}
+function findCodeBodyBounds(tokens, start) {
+  let cache = caches2.get(tokens);
+  if (!cache) {
+    cache = new Map;
+    caches2.set(tokens, cache);
+  }
+  const cached = cache.get(start);
+  if (cached)
+    return cached;
+  const stack = [start];
+  let pos = start;
+  while (pos < tokens.length && tokens[pos]?.type !== "EOF") {
+    const rawEnd = rawRegionEnd(tokens, pos, tokens.length);
+    if (rawEnd > pos) {
+      pos = rawEnd;
+      continue;
+    }
+    const end = codeCloseEnd(tokens, pos);
+    if (end > pos) {
+      const result2 = { closeStart: pos, end, foundClose: true };
+      cache.set(stack.pop(), result2);
+      if (stack.length === 0)
+        return result2;
+      pos = end;
+      continue;
+    }
+    const bodyStart = nestedCodeBodyStart(tokens, pos);
+    if (bodyStart > pos) {
+      const child = cache.get(bodyStart);
+      if (child) {
+        pos = child.end;
+        if (!child.foundClose)
+          break;
+      } else {
+        stack.push(bodyStart);
+        pos = bodyStart;
+      }
+      continue;
+    }
+    pos++;
+  }
+  const result = { closeStart: pos, end: pos, foundClose: false };
+  for (const bodyStart of stack)
+    cache.set(bodyStart, result);
+  return result;
+}
+
+// packages/parser/src/parser/rules/block/math/boundary.ts
+var nameRanges = new WeakMap;
+var bodyCaches = new WeakMap;
+function findNameEnd(tokens, start) {
+  const cached = nameRanges.get(tokens);
+  if (cached && start >= cached.start && start <= cached.end)
+    return cached.end;
+  let end = start;
+  while (end < tokens.length) {
+    const type = tokens[end]?.type;
+    if (type === "BLOCK_CLOSE" || type === "WHITESPACE" || type === "NEWLINE" || type === "EOF")
+      break;
+    end++;
+  }
+  nameRanges.set(tokens, { start, end });
+  return end;
+}
+function findMathOpen(tokens, start) {
+  const name = tokens[start + 1];
+  if (tokens[start]?.type !== "BLOCK_OPEN" || name?.type !== "IDENTIFIER" && name?.type !== "TEXT" || name.value.toLowerCase() !== "math" || tokens[start + 2]?.type === "UNDERSCORE")
+    return null;
+  let pos = start + 2;
+  while (tokens[pos]?.type === "WHITESPACE")
+    pos++;
+  const nameStart = pos;
+  if (tokens[pos]?.type === "IDENTIFIER" || tokens[pos]?.type === "TEXT") {
+    pos = findNameEnd(tokens, pos);
+  }
+  const nameEnd = pos;
+  while (tokens[pos]?.type === "WHITESPACE")
+    pos++;
+  if (tokens[pos]?.type !== "BLOCK_CLOSE")
+    return null;
+  pos++;
+  if (tokens[pos]?.type === "NEWLINE")
+    pos++;
+  return { nameStart, nameEnd, bodyStart: pos };
+}
+function mathCloseEnd(tokens, start) {
+  if (tokens[start]?.type !== "BLOCK_END_OPEN" || tokens[start + 1]?.value.toLowerCase() !== "math" || tokens[start + 2]?.type !== "BLOCK_CLOSE")
+    return start;
+  const end = start + 3;
+  return tokens[end]?.type === "NEWLINE" ? end + 1 : end;
+}
+function findMathBodyBounds(tokens, start) {
+  let cache = bodyCaches.get(tokens);
+  if (!cache) {
+    cache = new Map;
+    bodyCaches.set(tokens, cache);
+  }
+  const visited = [];
+  let result = {
+    closeStart: tokens.length,
+    end: tokens.length,
+    foundClose: false,
+    hasContent: false
+  };
+  for (let pos = start;pos < tokens.length; pos++) {
+    const cached = cache.get(pos);
+    if (cached) {
+      result = cached;
+      break;
+    }
+    const end = mathCloseEnd(tokens, pos);
+    if (end > pos) {
+      result = { closeStart: pos, end, foundClose: true, hasContent: false };
+      cache.set(pos, result);
+      break;
+    }
+    visited.push(pos);
+  }
+  for (let i = visited.length - 1;i >= 0; i--) {
+    const pos = visited[i];
+    const token5 = tokens[pos];
+    if (!result.hasContent && (token5.type === "BACKSLASH_BREAK" || token5.value.trim() !== "")) {
+      result = { ...result, hasContent: true };
+    }
+    cache.set(pos, result);
+  }
+  return result;
+}
+
+// packages/parser/src/parser/rules/opaque-probe.ts
+function createOpaqueProbe(ctx) {
+  return {
+    ...ctx,
+    diagnostics: [],
+    footnotes: [],
+    tocEntries: [],
+    codeBlocks: [],
+    htmlBlocks: [],
+    bibcites: [],
+    scope: {
+      ...ctx.scope,
+      inlineEnd: undefined,
+      tableFormatting: undefined,
+      blockCloseCondition: () => true
+    }
+  };
+}
+function opaqueRuleEnd(probe, pos, rules, requireClosed = false) {
+  const token5 = probe.tokens[pos];
+  if (!token5)
+    return pos;
+  probe.pos = pos;
+  for (const rule of rules) {
+    if (!rule.startTokens.includes(token5.type))
+      continue;
+    if (rule.name === "code") {
+      const open = findCodeOpen(probe.tokens, pos);
+      if (!open)
+        continue;
+      if (open.closingSwallowed) {
+        if (!requireClosed)
+          return open.bodyStart;
+        continue;
+      }
+      const bounds = findCodeBodyBounds(probe.tokens, open.bodyStart);
+      if (!requireClosed || bounds.foundClose)
+        return bounds.end;
+      continue;
+    }
+    if (rule.name === "math") {
+      const open = findMathOpen(probe.tokens, pos);
+      if (!open)
+        continue;
+      const bounds = findMathBodyBounds(probe.tokens, open.bodyStart);
+      if (bounds.hasContent && (!requireClosed || bounds.foundClose))
+        return bounds.end;
+      continue;
+    }
+    const result = rule.parse(probe);
+    if (result.success)
+      return pos + result.consumed;
+  }
+  return pos;
+}
+
+// packages/parser/src/parser/rules/tokens.ts
+function currentToken(ctx) {
+  return ctx.tokens[ctx.pos] ?? eofToken();
+}
+function eofToken() {
+  return {
+    type: "EOF",
+    value: "",
+    position: { start: { line: 0, column: 0, offset: 0 }, end: { line: 0, column: 0, offset: 0 } },
+    lineStart: false
+  };
+}
+function hasClosingMarkerBeforeNewline(ctx, markerType, markerValue) {
+  let pos = ctx.pos;
+  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
+    const token5 = ctx.tokens[pos];
+    if (!token5 || token5.type === "NEWLINE" || token5.type === "EOF") {
+      return false;
+    }
+    if (token5.type === markerType) {
+      if (markerValue === undefined || token5.value === markerValue) {
+        return true;
+      }
+    }
+    pos++;
+  }
+  return false;
+}
+// packages/parser/src/parser/rules/block/code/attributes.ts
+function repairSwallowedCodeClose(ctx, pos, attrs) {
+  const prevToken = ctx.tokens[pos - 1];
+  if (prevToken?.type !== "QUOTED_STRING" || !prevToken.value.includes("]]")) {
+    return null;
+  }
+  const rawValue = prevToken.value;
+  const bracketIdx = rawValue.indexOf("]]");
+  const truncatedValue = rawValue.startsWith('"') ? rawValue.slice(1, bracketIdx) : rawValue.slice(0, bracketIdx);
+  for (const key of Object.keys(attrs)) {
+    const stored = attrs[key];
+    if (stored === rawValue || stored === rawValue.slice(1, -1) || stored === rawValue.slice(1)) {
+      attrs[key] = truncatedValue;
+      break;
+    }
+  }
+  return {
+    closingSwallowed: rawValue.includes("[[/code]]")
+  };
+}
+
+// packages/parser/src/parser/rules/block/paragraph/span-markers.ts
+function processCloseSpanMarkers(elements) {
+  let result = null;
+  for (let i = 0;i < elements.length; i++) {
+    const elem = elements[i];
+    if (!elem)
+      continue;
+    if (isCloseSpanMarker(elem)) {
+      if (result === null) {
+        result = elements.slice(0, i);
+      }
+      if (result.length > 0) {
+        const spanContent = [...result];
+        result.length = 0;
+        result.push({
+          element: "container",
+          data: {
+            type: "span",
+            attributes: {},
+            elements: spanContent
+          }
+        });
+      }
+    } else {
+      result?.push(elem);
+    }
+  }
+  return result ?? elements;
+}
+function isCloseSpanMarker(elem) {
+  return elem.element === "container" && elem.data && typeof elem.data === "object" && "type" in elem.data && elem.data.type === "span" && "attributes" in elem.data && typeof elem.data.attributes === "object" && elem.data.attributes !== null && "_closeSpan" in elem.data.attributes;
+}
+
+// packages/parser/src/parser/rules/inline/parsing/preserved-line-break.ts
+function createPreservedTrailingLineBreak() {
+  const lineBreak = { element: "line-break" };
+  lineBreak._preservedTrailingBreak = true;
+  return lineBreak;
+}
+function createPreservedLeadingLineBreak() {
+  const lineBreak = { element: "line-break", _preservedLeadingBreak: true };
+  return lineBreak;
+}
+function isPreservedLeadingLineBreak(element) {
+  return element?.element === "line-break" && element._preservedLeadingBreak === true;
+}
+
+// packages/parser/src/parser/rules/block/paragraph/normalize.ts
+function normalizeParagraphElements(source) {
+  let elements = processCloseSpanMarkers(source);
+  removeTrailingLineBreaks(elements);
+  removeTrailingWhitespaceText(elements);
+  elements = removeLeadingLineBreaks(elements);
+  return elements;
+}
+function removeTrailingLineBreaks(elements) {
+  while (elements.length > 0 && elements[elements.length - 1]?.element === "line-break") {
+    const lastEl = elements[elements.length - 1];
+    if (lastEl._preservedTrailingBreak) {
+      delete lastEl._preservedTrailingBreak;
+      break;
+    }
+    elements.pop();
+  }
+}
+function removeTrailingWhitespaceText(elements) {
+  while (elements.length > 0) {
+    const last = elements[elements.length - 1];
+    if (last?.element === "text" && "data" in last && typeof last.data === "string" && last.data.trim() === "") {
+      elements.pop();
+    } else {
+      break;
+    }
+  }
+}
+function removeLeadingLineBreaks(elements) {
+  let first = 0;
+  while (first < elements.length && elements[first]?.element === "line-break" && !isPreservedLeadingLineBreak(elements[first])) {
+    first++;
+  }
+  return first > 0 ? elements.slice(first) : elements;
+}
+
+// packages/parser/src/parser/rules/block/code/content.ts
+function collectCodeContent(ctx, startPos, closingSwallowed) {
+  if (closingSwallowed)
+    return { contents: "", consumed: 0, foundClose: true };
+  const bounds = findCodeBodyBounds(ctx.tokens, startPos);
+  return {
+    contents: ctx.tokens.slice(startPos, bounds.closeStart).map((token5) => token5.value).join(""),
+    consumed: bounds.end - startPos,
+    foundClose: bounds.foundClose
+  };
+}
+
+// packages/parser/src/parser/rules/block/code/index.ts
+var codeBlockRule = {
+  name: "code",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  parse(ctx) {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+    const open = findCodeOpen(ctx.tokens, ctx.pos);
+    if (!open)
+      return { success: false };
+    const attrResult = parseAttributesRaw(ctx, ctx.pos + 2);
+    if (open.repaired)
+      repairSwallowedCodeClose(ctx, open.attributesEnd, attrResult.attrs);
+    let pos = open.bodyStart;
+    let consumed = pos - ctx.pos;
+    const contentResult = collectCodeContent(ctx, pos, open.closingSwallowed);
+    let codeContent = contentResult.contents.replace(/\n$/, "");
+    consumed += contentResult.consumed;
+    pos += contentResult.consumed;
+    if (!contentResult.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/code]] for [[code]]",
+        position: openToken.position
+      });
+    }
+    const codeBlockData = {
+      contents: codeContent,
+      language: attrResult.attrs.type ?? null,
+      name: attrResult.attrs.name ?? null
+    };
+    ctx.codeBlocks.push(codeBlockData);
+    const elements = [{ element: "code", data: codeBlockData }];
+    if (ctx.tokens[pos]?.type === "NEWLINE" && !getParagraphNewlineBoundary(ctx, pos, false).shouldBreak && !ctx.scope.blockCloseCondition?.({ ...ctx, pos: pos + 1 })) {
+      const after = parseInlineUntil({ ...ctx, pos: pos + 1 }, "PARAGRAPH_BREAK");
+      elements.push({ element: "line-break" }, ...normalizeParagraphElements(after.elements));
+      consumed += 1 + after.consumed;
+    }
+    return { success: true, elements, consumed };
+  }
+};
+
+// packages/parser/src/parser/rules/block/math/index.ts
+var mathBlockRule = {
+  name: "math",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  parse(ctx) {
+    const openToken = currentToken(ctx);
+    const open = findMathOpen(ctx.tokens, ctx.pos);
+    if (!open)
+      return { success: false };
+    const bounds = findMathBodyBounds(ctx.tokens, open.bodyStart);
+    if (!bounds.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/math]] for [[math]]",
+        position: openToken.position
+      });
+    }
+    if (!bounds.hasContent) {
+      return { success: false };
+    }
+    const latexSource = ctx.tokens.slice(open.bodyStart, bounds.closeStart).map((token5) => token5.type === "BACKSLASH_BREAK" ? "\\\n" : token5.value).join("").trim();
+    const name = ctx.tokens.slice(open.nameStart, open.nameEnd).map((token5) => token5.value).join("");
+    return {
+      success: true,
+      elements: [
+        {
+          element: "math",
+          data: {
+            name: name || null,
+            "latex-source": latexSource
+          }
+        }
+      ],
+      consumed: bounds.end - ctx.pos
+    };
+  }
+};
+
+// packages/parser/src/parser/rules/inline/link-triple/fallback.ts
+function literalOpenLink(value) {
+  return {
+    success: true,
+    elements: [{ element: "text", data: value }],
+    consumed: 1
+  };
+}
+
+// packages/parser/src/parser/rules/inline/link-triple/label.ts
+function buildTripleLinkLabel(args) {
+  if (args.isPage && args.foundPipe && !args.labelText.trim())
+    return "page";
+  return {
+    text: getTripleLinkDisplayText({
+      ...args,
+      originalTarget: args.isPage && !args.foundPipe ? args.originalTarget.split("#")[0] : args.originalTarget
+    })
+  };
+}
+function getTripleLinkDisplayText(args) {
+  const trimmedLabel = args.labelText.trim();
+  if (args.foundPipe) {
+    return trimmedLabel || args.finalTarget;
+  }
+  const colonIdx = args.originalTarget.indexOf(":");
+  if (colonIdx !== -1 && !args.originalTarget.startsWith("http") && !args.originalTarget.startsWith("*")) {
+    return args.originalTarget.slice(colonIdx + 1).trim();
+  }
+  return args.originalTarget;
+}
+
+// packages/parser/src/parser/rules/inline/link-triple/syntax.ts
+function hasClosingLinkMarker(ctx, startPos) {
+  let pos = startPos;
+  while (pos < ctx.tokens.length) {
+    const token5 = ctx.tokens[pos];
+    if (!token5 || token5.type === "EOF") {
+      return false;
+    }
+    if (token5.type === "LINK_CLOSE") {
+      return true;
+    }
+    if (token5.type === "NEWLINE") {
+      const next = ctx.tokens[pos + 1];
+      if (next?.type === "NEWLINE" || next?.type === "LINK_CLOSE") {
+        return false;
+      }
+    }
+    pos++;
+  }
+  return false;
+}
+function collectTripleLinkParts(ctx, startPos) {
+  let target = "";
+  let labelText = "";
+  let foundPipe = false;
+  let consumed = 1;
+  let pos = startPos;
+  while (pos < ctx.tokens.length) {
+    const token5 = ctx.tokens[pos];
+    if (!token5 || token5.type === "LINK_CLOSE" || token5.type === "EOF") {
+      break;
+    }
+    if (token5.type === "NEWLINE") {
+      if (foundPipe) {
+        labelText += " ";
+      } else {
+        target += " ";
+      }
+      consumed++;
+      pos++;
+      continue;
+    }
+    if (token5.type === "PIPE" && !foundPipe) {
+      foundPipe = true;
+    } else if (foundPipe) {
+      labelText += token5.value;
+    } else {
+      target += token5.value;
+    }
+    consumed++;
+    pos++;
+  }
+  if (ctx.tokens[pos]?.type === "LINK_CLOSE") {
+    consumed++;
+  }
+  return { target, labelText, foundPipe, consumed };
+}
+
+// packages/parser/src/parser/rules/inline/link-triple/interwiki.ts
+var INTERWIKI_PREFIXES = new Set(["wikipedia", "google", "dictionary", "wikidot"]);
+function isInterwikiTarget(target) {
+  const colonIdx = target.indexOf(":");
+  if (colonIdx <= 0 || target.includes("/")) {
+    return false;
+  }
+  const prefix = target.slice(0, colonIdx).toLowerCase();
+  return INTERWIKI_PREFIXES.has(prefix);
+}
+
+// packages/parser/src/parser/rules/inline/link-triple/target.ts
+function normalizeTripleLinkTarget(trimmedTarget) {
+  if (trimmedTarget.startsWith("*")) {
+    return { target: trimmedTarget.slice(1), hasStar: true };
+  }
+  return { target: trimmedTarget, hasStar: false };
+}
+function isInvalidTripleLinkTarget(trimmedTarget, foundPipe) {
+  return trimmedTarget === "" && foundPipe || /#{2,}/.test(trimmedTarget);
+}
+function determineLinkTypeAndLocation(target) {
+  if (target.startsWith("#")) {
+    return { linkType: "anchor", link: target };
+  }
+  if (target.startsWith("http://") || target.startsWith("https://")) {
+    return { linkType: "direct", link: target };
+  }
+  if (isInterwikiTarget(target)) {
+    return { linkType: "interwiki", link: target };
+  }
+  return { linkType: "page", link: { site: null, page: target } };
+}
+
+// packages/parser/src/parser/rules/inline/link-triple/index.ts
+var linkTripleRule = {
+  name: "linkTriple",
+  startTokens: ["LINK_OPEN"],
+  parse(ctx) {
+    const startToken = currentToken(ctx);
+    if (!hasClosingLinkMarker(ctx, ctx.pos + 1)) {
+      return literalOpenLink(startToken.value);
+    }
+    const parts = collectTripleLinkParts(ctx, ctx.pos + 1);
+    const trimmedTarget = parts.target.trim();
+    if (isInvalidTripleLinkTarget(trimmedTarget, parts.foundPipe)) {
+      return literalOpenLink(startToken.value);
+    }
+    const normalized = normalizeTripleLinkTarget(trimmedTarget);
+    const { linkType, link } = determineLinkTypeAndLocation(normalized.target);
+    const label = buildTripleLinkLabel({
+      isPage: linkType === "page",
+      foundPipe: parts.foundPipe,
+      labelText: parts.labelText,
+      finalTarget: normalized.target,
+      originalTarget: trimmedTarget
+    });
+    return {
+      success: true,
+      elements: [
+        {
+          element: "link",
+          data: {
+            type: linkType,
+            link,
+            extra: null,
+            label,
+            target: normalized.hasStar && linkType === "direct" ? "new-tab" : null
+          }
+        }
+      ],
+      consumed: parts.consumed
+    };
+  }
+};
+
+// packages/parser/src/parser/rules/block/note/boundary.ts
+var opaqueRules = [codeBlockRule, mathBlockRule, linkTripleRule];
+var boundsCache = new WeakMap;
+var closeCache = new WeakMap;
+function tagEnd(tokens, pos, name, close = false) {
+  return tokens[pos]?.type === (close ? "BLOCK_END_OPEN" : "BLOCK_OPEN") && tokens[pos + 1]?.value.toLowerCase() === name && tokens[pos + 2]?.type === "BLOCK_CLOSE" ? pos + 3 : pos;
+}
+function findClose(probe, start, name) {
+  let byName = closeCache.get(probe.tokens);
+  if (!byName) {
+    byName = new Map;
+    closeCache.set(probe.tokens, byName);
+  }
+  let cache = byName.get(name);
+  if (!cache) {
+    cache = new Map;
+    byName.set(name, cache);
+  }
+  if (cache.has(start))
+    return cache.get(start);
+  const visited = [];
+  let result = -1;
+  for (let pos = start;pos < probe.tokens.length; pos++) {
+    if (cache.has(pos)) {
+      result = cache.get(pos);
+      break;
+    }
+    visited.push(pos);
+    const protectedEnd = protectedInlineRegionEnd(probe.tokens, pos, probe.tokens.length);
+    if (protectedEnd > pos) {
+      pos = protectedEnd - 1;
+      continue;
+    }
+    if (tagEnd(probe.tokens, pos, name, true) > pos) {
+      result = pos;
+      break;
+    }
+    const opaqueEnd = opaqueRuleEnd(probe, pos, opaqueRules, true);
+    if (opaqueEnd > pos) {
+      pos = opaqueEnd - 1;
+      continue;
+    }
+    if (name === "note") {
+      const footnoteStart = tagEnd(probe.tokens, pos, "footnote");
+      if (footnoteStart > pos) {
+        const end = findClose(probe, footnoteStart, "footnote");
+        if (end >= 0)
+          pos = end + 2;
+      }
+    }
+  }
+  for (const pos of visited)
+    cache.set(pos, result);
+  return result;
+}
+function findNoteBounds(ctx, start = ctx.pos) {
+  const openEnd = tagEnd(ctx.tokens, start, "note");
+  if (openEnd === start || ctx.tokens[openEnd]?.type !== "NEWLINE")
+    return null;
+  let cache = boundsCache.get(ctx.tokens);
+  if (!cache) {
+    cache = new Map;
+    boundsCache.set(ctx.tokens, cache);
+  }
+  if (cache.has(start))
+    return cache.get(start);
+  const close = findClose(createOpaqueProbe(ctx), openEnd + 1, "note");
+  const result = close < 0 ? null : { bodyStart: openEnd + 1, close, end: close + 3 };
+  cache.set(start, result);
+  return result;
+}
+
+// packages/parser/src/parser/rules/inline/parsing/block-boundary.ts
+function isExcludedBlockToken(ctx, tokenPos) {
+  const excluded = ctx.scope.excludedBlockNames;
+  if (!excluded?.size)
+    return false;
+  const token5 = ctx.tokens[tokenPos];
+  if (token5?.type !== "BLOCK_OPEN" && token5?.type !== "BLOCK_END_OPEN")
+    return false;
   const nameResult = parseBlockName(ctx, tokenPos + 1);
   return nameResult !== null && excluded.has(nameResult.name);
 }
@@ -1297,6 +2559,8 @@ function isUnknownBlockToken(ctx, tokenPos) {
     }
     return true;
   }
+  if (nameResult.name === "note")
+    return findNoteBounds(ctx, tokenPos) === null;
   return !KNOWN_BLOCK_NAMES.has(nameResult.name);
 }
 function isIndentAcceptingBlock(ctx, tokenPos) {
@@ -1320,7 +2584,13 @@ function isParagraphBreakingBlockStart(ctx, newlinePos, lookAhead) {
   if (!nextMeaningfulToken.lineStart && !isIndentedBlockOpener) {
     return false;
   }
-  return !parseImageOpen({ ...ctx, pos: nextPos }) && !isOrphanCloseSpan(ctx, nextPos) && !isAnchorName(ctx, nextPos) && !isInvalidBlockOpen(ctx, nextPos) && !isInvalidHeading(ctx, nextPos) && !isExcludedBlockStart(ctx, nextPos) && !isUnknownBlockStart(ctx, nextPos);
+  return !parseImageOpen({ ...ctx, pos: nextPos }) && !isOrphanCloseSpan(ctx, nextPos) && !isAnchorName(ctx, nextPos) && !isInvalidBlockOpen(ctx, nextPos) && !isInvalidHeading(ctx, nextPos) && !isInvalidListMarker(ctx, nextPos) && !isExcludedBlockStart(ctx, nextPos) && !isUnknownBlockStart(ctx, nextPos);
+}
+function isInvalidListMarker(ctx, markerPos) {
+  const marker = ctx.tokens[markerPos];
+  if (marker?.type !== "LIST_BULLET" && marker?.type !== "LIST_NUMBER")
+    return false;
+  return ctx.tokens[markerPos + 1]?.type !== "WHITESPACE";
 }
 function isOrphanCloseSpan(ctx, blockEndOpenPos) {
   const token5 = ctx.tokens[blockEndOpenPos];
@@ -1406,13 +2676,6 @@ function skipWhitespaceAfterNewline(ctx, newlinePos) {
   return lookAhead;
 }
 
-// packages/parser/src/parser/rules/inline/parsing/preserved-line-break.ts
-function createPreservedTrailingLineBreak() {
-  const lineBreak = { element: "line-break" };
-  lineBreak._preservedTrailingBreak = true;
-  return lineBreak;
-}
-
 // packages/parser/src/parser/rules/inline/parsing/simple-token.ts
 function parseSimpleInlineToken(token5, nextToken) {
   if (token5.type === "TEXT" && token5.value !== "(") {
@@ -1429,12 +2692,13 @@ function parseInlineUntil(ctx, endType) {
   const nodes = [];
   let consumed = 0;
   let pos = ctx.pos;
+  let consumedEmptyRaw = false;
   const paragraphMode = endType === "PARAGRAPH_BREAK";
   const multiline = paragraphMode || FORMATTING_CLOSE_TOKENS.has(endType);
   let inlineEnd = ctx.scope.inlineEnd ?? ctx.tokens.length;
   if (!multiline) {
     for (let end = ctx.pos;end < inlineEnd; end++) {
-      const protectedEnd = protectedInlineRegionEnd(ctx.tokens, end, inlineEnd);
+      const protectedEnd = Math.max(parseButtonSyntax(ctx, end, inlineEnd)?.end ?? end, parseSocialSyntax(ctx, end, inlineEnd)?.end ?? end, parseDateSyntax(ctx, end, inlineEnd)?.end ?? end, emailRegionEnd(ctx.tokens, end, inlineEnd), protectedInlineRegionEnd(ctx.tokens, end, inlineEnd));
       if (protectedEnd > end) {
         end = protectedEnd - 1;
         continue;
@@ -1483,10 +2747,11 @@ function parseInlineUntil(ctx, endType) {
       consumed++;
       continue;
     }
-    if (token5.type === endType) {
+    const hasEmail = emailRegionEnd(ctx.tokens, pos, inlineEnd) > pos;
+    if (token5.type === endType && !hasEmail) {
       break;
     }
-    if (canCollectLongPlainTextRuns) {
+    if (canCollectLongPlainTextRuns && !hasEmail) {
       const plainTextRun = collectLongPlainTextRun(ctx, pos, endType);
       if (plainTextRun) {
         nodes.push({ element: "text", data: plainTextRun.value });
@@ -1496,7 +2761,7 @@ function parseInlineUntil(ctx, endType) {
       }
     }
     const simpleToken = parseSimpleInlineToken(token5, ctx.tokens[pos + 1]);
-    if (simpleToken) {
+    if (simpleToken && !hasEmail) {
       nodes.push(simpleToken.element);
       consumed += simpleToken.consumed;
       pos += simpleToken.consumed;
@@ -1507,6 +2772,10 @@ function parseInlineUntil(ctx, endType) {
     for (const rule of getCandidateInlineRules(inlineRules, token5.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
+        stripAutomaticLineBreak(nodes, result.stripLeadingLineBreak);
+        if (rule.name === "raw" && result.elements.length === 0 && nodes.length === 0) {
+          consumedEmptyRaw = true;
+        }
         if (rule.name === "comment") {
           let after = pos + result.consumed;
           while (ctx.tokens[after]?.type === "WHITESPACE")
@@ -1523,165 +2792,39 @@ function parseInlineUntil(ctx, endType) {
             }
             if (nodes.at(-1)?.element === "line-break")
               nodes.pop();
-          }
-        }
-        nodes.push(...result.elements);
-        consumed += result.consumed;
-        pos += result.consumed;
-        matched = true;
-        break;
-      }
-    }
-    if (!matched) {
-      nodes.push({ element: "text", data: token5.value });
-      consumed++;
-      pos++;
-    }
-  }
-  return { elements: nodes, consumed };
-}
-var FORMATTING_CLOSE_TOKENS = new Set([
-  "BOLD_MARKER",
-  "ITALIC_MARKER",
-  "UNDERLINE_MARKER",
-  "STRIKE_MARKER",
-  "SUPER_MARKER",
-  "SUB_MARKER",
-  "MONO_CLOSE",
-  "COLOR_MARKER"
-]);
-// packages/parser/src/parser/rules/block/parsing/attributes/names.ts
-function consumeAttributeName(ctx, startPos, startConsumed, startName, options) {
-  if (startName === "_" && isAttributeWordToken(ctx.tokens[startPos])) {
-    startName += ctx.tokens[startPos]?.value ?? "";
-    startPos++;
-    startConsumed++;
-  }
-  return options.strikeHyphens ? consumeRawNameSuffix(ctx, startPos, startConsumed, startName, options.hyphenatedNames) : consumeSafeNameSuffix(ctx, startPos, startConsumed, startName);
-}
-function isAttributeNameToken(token5) {
-  return isAttributeWordToken(token5) || token5?.type === "UNDERSCORE";
-}
-function consumeSafeNameSuffix(ctx, startPos, startConsumed, startName) {
-  let name = startName;
-  let pos = startPos;
-  let consumed = startConsumed;
-  while (isAttributeNameSeparator(ctx.tokens[pos]) && isAttributeWordToken(ctx.tokens[pos + 1])) {
-    name += ctx.tokens[pos]?.value ?? "";
-    pos++;
-    consumed++;
-    name += ctx.tokens[pos]?.value ?? "";
-    pos++;
-    consumed++;
-  }
-  return { name, pos, consumed };
-}
-function consumeRawNameSuffix(ctx, startPos, startConsumed, startName, hyphenatedNames) {
-  let name = startName;
-  let pos = startPos;
-  let consumed = startConsumed;
-  while (isAttributeNameSeparator(ctx.tokens[pos])) {
-    while (isAttributeNameSeparator(ctx.tokens[pos])) {
-      if (hyphenatedNames || ctx.tokens[pos]?.type === "UNDERSCORE") {
-        name += ctx.tokens[pos]?.value ?? "-";
-      }
-      pos++;
-      consumed++;
-    }
-    if (!isAttributeWordToken(ctx.tokens[pos])) {
-      break;
-    }
-    if (hyphenatedNames || name.endsWith("_")) {
-      name += ctx.tokens[pos]?.value ?? "";
-    }
-    pos++;
-    consumed++;
-  }
-  return { name, pos, consumed };
-}
-function isAttributeWordToken(token5) {
-  return token5?.type === "TEXT" || token5?.type === "IDENTIFIER";
-}
-function isAttributeNameSeparator(token5) {
-  return token5?.type === "TEXT" && token5.value === "-" || token5?.type === "STRIKE_MARKER" || token5?.type === "UNDERSCORE";
-}
-
-// packages/parser/src/parser/rules/block/parsing/attributes/values.ts
-function consumeAttributeValue(token5) {
-  if (!token5) {
-    return null;
-  }
-  if (token5.type === "QUOTED_STRING") {
-    return { value: stripQuotes(token5.value) };
-  }
-  if (isAttributeNameToken(token5)) {
-    return { value: token5.value };
-  }
-  return null;
-}
-function stripQuotes(value) {
-  return value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
-}
-
-// packages/parser/src/parser/rules/block/parsing/attributes/scanner.ts
-function scanAttributes(ctx, startPos, options) {
-  const attrs = {};
-  let pos = startPos;
-  let consumed = 0;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || isAttributeTerminator(token5)) {
-      break;
+          }
+        }
+        for (const element of result.elements) {
+          nodes.push(paragraphMode && consumedEmptyRaw && nodes.length === 0 && token5.type === "NEWLINE" && element.element === "line-break" ? createPreservedLeadingLineBreak() : element);
+        }
+        consumed += result.consumed;
+        pos += result.consumed;
+        matched = true;
+        break;
+      }
     }
-    if (token5.type === "WHITESPACE") {
-      pos++;
+    if (!matched) {
+      nodes.push({ element: "text", data: token5.value });
       consumed++;
-      continue;
-    }
-    if (!isAttributeNameToken(token5)) {
       pos++;
-      consumed++;
-      continue;
-    }
-    let name = token5.value;
-    pos++;
-    consumed++;
-    const nameResult = consumeAttributeName(ctx, pos, consumed, name, options);
-    pos = nameResult.pos;
-    consumed = nameResult.consumed;
-    name = nameResult.name.toLowerCase();
-    if (ctx.tokens[pos]?.type !== "EQUALS") {
-      attrs[name] = "true";
-      continue;
-    }
-    pos++;
-    consumed++;
-    const valueResult = consumeAttributeValue(ctx.tokens[pos]);
-    if (!valueResult) {
-      continue;
     }
-    attrs[name] = valueResult.value;
-    pos++;
-    consumed++;
   }
-  return { attrs, consumed };
-}
-function isAttributeTerminator(token5) {
-  return token5.type === "BLOCK_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF";
-}
-
-// packages/parser/src/parser/rules/block/parsing/attributes/index.ts
-function parseAttributes(ctx, startPos) {
-  const result = scanAttributes(ctx, startPos, { hyphenatedNames: true, strikeHyphens: false });
-  return { attrs: filterUnsafeAttributes(result.attrs), consumed: result.consumed };
-}
-function parseAttributesRaw(ctx, startPos, hyphenatedNames = true) {
-  return scanAttributes(ctx, startPos, { hyphenatedNames, strikeHyphens: true });
+  return { elements: nodes, consumed };
 }
+var FORMATTING_CLOSE_TOKENS = new Set([
+  "BOLD_MARKER",
+  "ITALIC_MARKER",
+  "UNDERLINE_MARKER",
+  "STRIKE_MARKER",
+  "SUPER_MARKER",
+  "SUB_MARKER",
+  "MONO_CLOSE",
+  "COLOR_MARKER"
+]);
 // packages/parser/src/parser/parse/block.ts
-function parseNextBlock(ctx, skipWhitespace2, isAtEnd2) {
+function parseNextBlock(ctx, skipWhitespace2, isAtEnd3) {
   skipWhitespace2();
-  if (isAtEnd2()) {
+  if (isAtEnd3()) {
     return [];
   }
   const token5 = ctx.tokens[ctx.pos];
@@ -1700,7 +2843,7 @@ function parseNextBlock(ctx, skipWhitespace2, isAtEnd2) {
     }
   }
   const result = ctx.blockFallbackRule.parse(ctx);
-  if (result.success && result.elements.length > 0) {
+  if (result.success) {
     ctx.pos += result.consumed;
     return result.elements;
   }
@@ -1710,35 +2853,6 @@ function parseNextBlock(ctx, skipWhitespace2, isAtEnd2) {
 
 // packages/parser/src/parser/parse/context.ts
 var import_ast6 = require("@wdprlib/ast");
-
-// packages/parser/src/parser/rules/tokens.ts
-function currentToken(ctx) {
-  return ctx.tokens[ctx.pos] ?? eofToken();
-}
-function eofToken() {
-  return {
-    type: "EOF",
-    value: "",
-    position: { start: { line: 0, column: 0, offset: 0 }, end: { line: 0, column: 0, offset: 0 } },
-    lineStart: false
-  };
-}
-function hasClosingMarkerBeforeNewline(ctx, markerType, markerValue) {
-  let pos = ctx.pos;
-  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "NEWLINE" || token5.type === "EOF") {
-      return false;
-    }
-    if (token5.type === markerType) {
-      if (markerValue === undefined || token5.value === markerValue) {
-        return true;
-      }
-    }
-    pos++;
-  }
-  return false;
-}
 // packages/parser/src/parser/rules/block/heading/open.ts
 function parseHeadingOpen(ctx) {
   const marker = ctx.tokens[ctx.pos];
@@ -1984,10 +3098,11 @@ function parseNativeListLine(ctx, startPos) {
   const ltype = markerToken.type === "LIST_BULLET" ? "bullet" : "numbered";
   pos++;
   consumed++;
-  if (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
+  if (ctx.tokens[pos]?.type !== "WHITESPACE") {
+    return { kind: "stop" };
   }
+  pos++;
+  consumed++;
   const inlineCtx = { ...ctx, pos };
   const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
   consumed += inlineResult.consumed;
@@ -2097,9 +3212,9 @@ function appendBareParagraphElements(state, elements) {
 function appendBareParagraphText(state, text) {
   state.current.push({ element: "text", data: text });
 }
-function appendBareParagraphLineBreakIfNeeded(state) {
+function appendBareParagraphLineBreakIfNeeded(state, token5) {
   if (state.current.length > 0) {
-    state.current.push({ element: "line-break" });
+    state.current.push(createAutomaticLineBreak(token5));
   }
 }
 function flushBareParagraph(state) {
@@ -2204,7 +3319,7 @@ function parseBareListContent(ctx, startPos, listType) {
       if (consecutiveNewlines >= 2) {
         flushBareParagraph(paragraphState);
       } else {
-        appendBareParagraphLineBreakIfNeeded(paragraphState);
+        appendBareParagraphLineBreakIfNeeded(paragraphState, token5);
       }
       continue;
     }
@@ -2216,6 +3331,7 @@ function parseBareListContent(ctx, startPos, listType) {
     for (const rule of getCandidateInlineRules(ctx.inlineRules, token5.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
+        stripAutomaticLineBreak(paragraphState.current, result.stripLeadingLineBreak);
         appendBareParagraphElements(paragraphState, result.elements);
         consumed += result.consumed;
         pos += result.consumed;
@@ -2254,7 +3370,7 @@ function parseListItemBlockContent(ctx, pos, token5) {
   for (const rule of getCandidateBlockRules(filteredBlockRules, token5)) {
     const result = rule.parse(blockCtx);
     if (result.success) {
-      return { matched: true, elements: result.elements, consumed: result.consumed };
+      return { matched: true, ...result };
     }
   }
   return { matched: false, elements: [], consumed: 0 };
@@ -2273,7 +3389,7 @@ function parseListItemInlineContent(ctx, pos, tokenType) {
   for (const rule of getCandidateInlineRules(ctx.inlineRules, tokenType)) {
     const result = rule.parse(inlineCtx);
     if (result.success) {
-      return { matched: true, elements: result.elements, consumed: result.consumed };
+      return { matched: true, ...result };
     }
   }
   return { matched: false, elements: [], consumed: 0 };
@@ -2315,7 +3431,9 @@ function collectPostLiTrailingContent(ctx, startPos, listType) {
     }
     const inlineResult = parseListItemInlineContent(ctx, pos, token5.type);
     if (inlineResult.matched) {
-      elements.push(...inlineResult.elements);
+      stripAutomaticLineBreak(elements, inlineResult.stripLeadingLineBreak);
+      for (const element of inlineResult.elements)
+        elements.push(element);
       consumed += inlineResult.consumed;
       pos += inlineResult.consumed;
       continue;
@@ -2360,7 +3478,7 @@ function collectLiItemContent(ctx, startPos, listType, parseNestedList) {
     if (token5.type === "NEWLINE") {
       const newlineResult = consumeLiItemNewlines(ctx, pos, elements.length > 0);
       if (newlineResult.addLineBreak) {
-        elements.push({ element: "line-break" });
+        elements.push(createAutomaticLineBreak(token5));
       }
       pos += newlineResult.consumed;
       consumed += newlineResult.consumed;
@@ -2368,14 +3486,17 @@ function collectLiItemContent(ctx, startPos, listType, parseNestedList) {
     }
     const blockResult = parseListItemBlockContent(ctx, pos, token5);
     if (blockResult.matched) {
-      elements.push(...blockResult.elements);
+      for (const element of blockResult.elements)
+        elements.push(element);
       consumed += blockResult.consumed;
       pos += blockResult.consumed;
       continue;
     }
     const inlineResult = parseListItemInlineContent(ctx, pos, token5.type);
     if (inlineResult.matched) {
-      elements.push(...inlineResult.elements);
+      stripAutomaticLineBreak(elements, inlineResult.stripLeadingLineBreak);
+      for (const element of inlineResult.elements)
+        elements.push(element);
       consumed += inlineResult.consumed;
       pos += inlineResult.consumed;
       continue;
@@ -2446,7 +3567,8 @@ function parseLiItem(ctx, startPos, listType, parseNestedList) {
     consumed += closeConsumed;
     pos += closeConsumed;
     const trailingResult = collectPostLiTrailingContent(ctx, pos, listType);
-    contentElements.push(...trailingResult.elements);
+    for (const element of trailingResult.elements)
+      contentElements.push(element);
     consumed += trailingResult.consumed;
   }
   return {
@@ -2706,7 +3828,7 @@ function sliceLineTokens(ctx, lines) {
   for (const { start, end } of lines) {
     for (let pos = start;pos < end; pos++) {
       const token5 = ctx.tokens[pos];
-      if (token5) {
+      if (token5 && token5.type !== "BACKSLASH_BREAK") {
         tokens.push(token5);
       }
     }
@@ -2876,7 +3998,8 @@ function parseDefinitionItemKey(ctx, startPos) {
     const inlineCtx = { ...ctx, pos };
     const result = parseInlineUntil(inlineCtx, "COLON");
     if (result.elements.length > 0) {
-      key.push(...result.elements);
+      for (const element of result.elements)
+        key.push(element);
       for (let i = 0;i < result.consumed; i++) {
         const t = ctx.tokens[pos + i];
         if (t)
@@ -2932,7 +4055,8 @@ function parseDefinitionItemValue(ctx, startPos) {
     const inlineCtx = { ...ctx, pos };
     const result = parseInlineUntil(inlineCtx, "NEWLINE");
     if (result.elements.length > 0) {
-      value.push(...result.elements);
+      for (const element of result.elements)
+        value.push(element);
       pos += result.consumed;
       consumed += result.consumed;
     } else {
@@ -3014,78 +4138,93 @@ var definitionListRule = {
   }
 };
 
-// packages/parser/src/parser/rules/block/paragraph/content.ts
-function parseInlineContent(ctx) {
-  return parseInlineUntil(ctx, "PARAGRAPH_BREAK");
+// packages/parser/src/parser/postprocess/divAdjacentParagraph.ts
+var unparsedDivStarts = new WeakSet;
+function markUnparsedDivStart(elements) {
+  const first = elements[0];
+  const text = first?.element === "container" && first.data.type === "paragraph" ? first.data.elements[0] : first;
+  if (text?.element === "text")
+    unparsedDivStarts.add(text);
 }
-
-// packages/parser/src/parser/rules/block/paragraph/span-markers.ts
-function processCloseSpanMarkers(elements) {
-  let result = null;
+function isUnparsedDivParagraph(el) {
+  if (!el || el.element !== "container")
+    return false;
+  return el.data.type === "paragraph" && el.data.elements.some((child) => unparsedDivStarts.has(child));
+}
+function isDivContainer(el) {
+  if (!el || el.element !== "container")
+    return false;
+  return el.data.type === "div";
+}
+function suppressAtLevel(elements) {
+  if (elements.length <= 1)
+    return elements;
+  const unwrap = Array.from({ length: elements.length }, () => false);
   for (let i = 0;i < elements.length; i++) {
-    const elem = elements[i];
-    if (!elem)
+    if (!isUnparsedDivParagraph(elements[i]))
       continue;
-    if (isCloseSpanMarker(elem)) {
-      if (result === null) {
-        result = elements.slice(0, i);
-      }
-      if (result.length > 0) {
-        const spanContent = [...result];
-        result.length = 0;
-        result.push({
-          element: "container",
-          data: {
-            type: "span",
-            attributes: {},
-            elements: spanContent
-          }
-        });
+    const prevIsDiv = i > 0 && isDivContainer(elements[i - 1]);
+    const nextIsDiv = i < elements.length - 1 && isDivContainer(elements[i + 1]);
+    if (prevIsDiv || nextIsDiv) {
+      unwrap[i] = true;
+    }
+  }
+  const result = [];
+  for (let i = 0;i < elements.length; i++) {
+    const el = elements[i];
+    if (!el)
+      continue;
+    if (unwrap[i] && el.element === "container") {
+      const inner = el.data.elements;
+      if (i > 0 && isDivContainer(elements[i - 1])) {
+        result.push({ element: "line-break" });
       }
+      result.push(...inner);
     } else {
-      result?.push(elem);
+      result.push(el);
     }
   }
-  return result ?? elements;
+  return result;
 }
-function isCloseSpanMarker(elem) {
-  return elem.element === "container" && elem.data && typeof elem.data === "object" && "type" in elem.data && elem.data.type === "span" && "attributes" in elem.data && typeof elem.data.attributes === "object" && elem.data.attributes !== null && "_closeSpan" in elem.data.attributes;
+function suppressDivAdjacentParagraphs(elements) {
+  return suppressAtLevel(elements);
 }
 
-// packages/parser/src/parser/rules/block/paragraph/normalize.ts
-function normalizeParagraphElements(source) {
-  let elements = processCloseSpanMarkers(source);
-  removeTrailingLineBreaks2(elements);
-  removeTrailingWhitespaceText(elements);
-  elements = removeLeadingLineBreaks(elements);
-  return elements;
+// packages/parser/src/parser/rules/block/div/close.ts
+function isDivClose(ctx) {
+  const token5 = ctx.tokens[ctx.pos];
+  if (token5?.type !== "BLOCK_END_OPEN")
+    return false;
+  const closeNameResult = parseBlockName(ctx, ctx.pos + 1);
+  return closeNameResult?.name === "div";
 }
-function removeTrailingLineBreaks2(elements) {
-  while (elements.length > 0 && elements[elements.length - 1]?.element === "line-break") {
-    const lastEl = elements[elements.length - 1];
-    if (lastEl._preservedTrailingBreak) {
-      delete lastEl._preservedTrailingBreak;
-      break;
-    }
-    elements.pop();
+function consumeDivClose(ctx, startPos) {
+  let pos = startPos;
+  let consumed = 0;
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    return { pos, consumed };
   }
-}
-function removeTrailingWhitespaceText(elements) {
-  while (elements.length > 0) {
-    const last = elements[elements.length - 1];
-    if (last?.element === "text" && "data" in last && typeof last.data === "string" && last.data.trim() === "") {
-      elements.pop();
-    } else {
-      break;
-    }
+  pos++;
+  consumed++;
+  const closeNameResult = parseBlockName(ctx, pos);
+  if (closeNameResult) {
+    pos += closeNameResult.consumed;
+    consumed += closeNameResult.consumed;
   }
-}
-function removeLeadingLineBreaks(elements) {
-  let first = 0;
-  while (first < elements.length && elements[first]?.element === "line-break") {
-    first++;
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    pos++;
+    consumed++;
   }
-  return first > 0 ? elements.slice(first) : elements;
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+  return { pos, consumed };
+}
+
+// packages/parser/src/parser/rules/block/paragraph/content.ts
+function parseInlineContent(ctx) {
+  return parseInlineUntil(ctx, "PARAGRAPH_BREAK");
 }
 
 // packages/parser/src/parser/rules/block/paragraph/index.ts
@@ -3095,25 +4234,30 @@ var paragraphRule = {
   requiresLineStart: false,
   parse(ctx) {
     const result = parseInlineContent(ctx);
-    if (result.elements.length === 0) {
+    if (result.consumed === 0) {
       return { success: false };
     }
     const elements = normalizeParagraphElements(result.elements);
     if (elements.length === 0) {
-      return { success: false };
+      return { success: true, elements: [], consumed: result.consumed };
     }
     const nextPos = ctx.pos + result.consumed;
     const nextToken = ctx.tokens[nextPos];
     if (nextToken?.type === "COLON" && nextToken.lineStart) {
+      if (isPreservedLeadingLineBreak(elements[0]))
+        elements[0] = { element: "line-break" };
       return {
         success: true,
         elements: [...elements, { element: "line-break" }],
         consumed: result.consumed
       };
     }
+    const wrapped = wrapParagraphElements(elements);
+    if (isDivClose(ctx))
+      markUnparsedDivStart(wrapped);
     return {
       success: true,
-      elements: wrapParagraphElements(elements),
+      elements: wrapped,
       consumed: result.consumed
     };
   }
@@ -3124,7 +4268,7 @@ function wrapParagraphElements(elements) {
   let bare = false;
   const flush = (trimBreaks = false) => {
     const content = trimBreaks ? normalizeParagraphElements(group) : group;
-    while (content[0]?.element === "line-break")
+    while (content[0]?.element === "line-break" && !isPreservedLeadingLineBreak(content[0]))
       content.shift();
     while (content.length) {
       const last = content.at(-1);
@@ -3136,6 +4280,8 @@ function wrapParagraphElements(elements) {
       content.shift();
     if (content[0]?.element === "text")
       content[0] = { element: "text", data: content[0].data.trimStart() };
+    if (isPreservedLeadingLineBreak(content[0]))
+      content[0] = { element: "line-break" };
     if (content.length)
       output.push(...bare || content.some((el) => el.element === "image") ? content : [
         {
@@ -3157,37 +4303,36 @@ function wrapParagraphElements(elements) {
   return output;
 }
 
-// packages/parser/src/parser/rules/block/div/close.ts
-function isDivClose(ctx) {
-  const token5 = ctx.tokens[ctx.pos];
-  if (token5?.type !== "BLOCK_END_OPEN")
-    return false;
-  const closeNameResult = parseBlockName(ctx, ctx.pos + 1);
-  return closeNameResult?.name === "div";
-}
-function consumeDivClose(ctx, startPos) {
-  let pos = startPos;
-  let consumed = 0;
-  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
-    return { pos, consumed };
-  }
-  pos++;
-  consumed++;
-  const closeNameResult = parseBlockName(ctx, pos);
-  if (closeNameResult) {
-    pos += closeNameResult.consumed;
-    consumed += closeNameResult.consumed;
-  }
-  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
-    pos++;
-    consumed++;
-  }
-  if (ctx.tokens[pos]?.type === "NEWLINE") {
-    pos++;
-    consumed++;
+// packages/parser/src/parser/rules/block/note/index.ts
+var excludedBlockNames = new Set(["note"]);
+var noteRule = {
+  name: "note",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  parse(ctx) {
+    const bounds = findNoteBounds(ctx);
+    if (!bounds)
+      return { success: false };
+    const body = parseBlocksUntil({
+      ...ctx,
+      tokens: ctx.tokens.slice(bounds.bodyStart, bounds.close),
+      pos: 0,
+      scope: {
+        ...ctx.scope,
+        inlineEnd: undefined,
+        tableFormatting: undefined,
+        blockCloseCondition: undefined
+      }
+    }, () => false, { excludedBlockNames });
+    return {
+      success: true,
+      consumed: bounds.end - ctx.pos,
+      elements: [
+        { element: "container", data: { type: "note", attributes: {}, elements: body.elements } }
+      ]
+    };
   }
-  return { pos, consumed };
-}
+};
 
 // packages/parser/src/parser/rules/block/div/nesting.ts
 var divCloseCountCache = new WeakMap;
@@ -3356,6 +4501,7 @@ function consumeFailedDiv(ctx) {
     pos++;
     consumed++;
   }
+  markUnparsedDivStart(elements);
   return {
     success: true,
     elements: [
@@ -3467,126 +4613,6 @@ var divRule = {
   }
 };
 
-// packages/parser/src/parser/rules/block/code/attributes.ts
-function repairSwallowedCodeClose(ctx, pos, attrs) {
-  const prevToken = ctx.tokens[pos - 1];
-  if (prevToken?.type !== "QUOTED_STRING" || !prevToken.value.includes("]]")) {
-    return null;
-  }
-  const rawValue = prevToken.value;
-  const bracketIdx = rawValue.indexOf("]]");
-  const truncatedValue = rawValue.startsWith('"') ? rawValue.slice(1, bracketIdx) : rawValue.slice(0, bracketIdx);
-  for (const key of Object.keys(attrs)) {
-    const stored = attrs[key];
-    if (stored === rawValue || stored === rawValue.slice(1, -1) || stored === rawValue.slice(1)) {
-      attrs[key] = truncatedValue;
-      break;
-    }
-  }
-  return {
-    closingSwallowed: rawValue.includes("[[/code]]")
-  };
-}
-
-// packages/parser/src/parser/rules/block/code/content.ts
-function collectCodeContent(ctx, startPos, closingSwallowed) {
-  const contentParts = [];
-  let pos = startPos;
-  let consumed = 0;
-  let foundClose = closingSwallowed;
-  while (!closingSwallowed && pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "EOF") {
-      break;
-    }
-    if (token5.type === "BLOCK_END_OPEN") {
-      const closeNameResult = parseBlockName(ctx, pos + 1);
-      if (closeNameResult?.name === "code") {
-        foundClose = true;
-        const closeConsumed = consumeCodeClose(ctx, pos, closeNameResult.consumed);
-        consumed += closeConsumed;
-        break;
-      }
-    }
-    contentParts.push(token5.value);
-    pos++;
-    consumed++;
-  }
-  return { contents: contentParts.join(""), consumed, foundClose };
-}
-function consumeCodeClose(ctx, startPos, closeNameConsumed) {
-  let pos = startPos + 1 + closeNameConsumed;
-  let consumed = 1 + closeNameConsumed;
-  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
-    pos++;
-    consumed++;
-  }
-  return consumed;
-}
-
-// packages/parser/src/parser/rules/block/code/index.ts
-var codeBlockRule = {
-  name: "code",
-  startTokens: ["BLOCK_OPEN"],
-  requiresLineStart: false,
-  parse(ctx) {
-    const openToken = currentToken(ctx);
-    if (openToken.type !== "BLOCK_OPEN") {
-      return { success: false };
-    }
-    let pos = ctx.pos + 1;
-    let consumed = 1;
-    const nameResult = parseBlockName(ctx, pos);
-    if (!nameResult || nameResult.name !== "code") {
-      return { success: false };
-    }
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
-    const attrResult = parseAttributesRaw(ctx, pos);
-    pos += attrResult.consumed;
-    consumed += attrResult.consumed;
-    let closingSwallowed = false;
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-      const repaired = repairSwallowedCodeClose(ctx, pos, attrResult.attrs);
-      if (!repaired)
-        return { success: false };
-      closingSwallowed = repaired.closingSwallowed;
-    } else {
-      pos++;
-      consumed++;
-    }
-    if (ctx.tokens[pos]?.type === "NEWLINE") {
-      pos++;
-      consumed++;
-    }
-    const contentResult = collectCodeContent(ctx, pos, closingSwallowed);
-    let codeContent = contentResult.contents.replace(/\n$/, "");
-    consumed += contentResult.consumed;
-    pos += contentResult.consumed;
-    if (!contentResult.foundClose) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: "Missing closing tag [[/code]] for [[code]]",
-        position: openToken.position
-      });
-    }
-    const codeBlockData = {
-      contents: codeContent,
-      language: attrResult.attrs.type ?? null,
-      name: attrResult.attrs.name ?? null
-    };
-    ctx.codeBlocks.push(codeBlockData);
-    const elements = [{ element: "code", data: codeBlockData }];
-    if (ctx.tokens[pos]?.type === "NEWLINE" && !getParagraphNewlineBoundary(ctx, pos, false).shouldBreak && !ctx.scope.blockCloseCondition?.({ ...ctx, pos: pos + 1 })) {
-      const after = parseInlineUntil({ ...ctx, pos: pos + 1 }, "PARAGRAPH_BREAK");
-      elements.push({ element: "line-break" }, ...normalizeParagraphElements(after.elements));
-      consumed += 1 + after.consumed;
-    }
-    return { success: true, elements, consumed };
-  }
-};
-
 // packages/parser/src/parser/rules/block/collapsible/attributes.ts
 function parseMultilineAttributes(ctx, startPos) {
   const attrs = {};
@@ -4015,7 +5041,9 @@ function parseTableCell(ctx, startPos, cellStart) {
     for (const rule of getCandidateInlineRules(inlineRules, token5.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        children.push(...result.elements);
+        stripAutomaticLineBreak(children, result.stripLeadingLineBreak);
+        for (const element of result.elements)
+          children.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;
@@ -4282,7 +5310,8 @@ function createCellContentAccumulator() {
     addInline(element) {
       currentSegment.push(element);
     },
-    addInlineElements(nextElements) {
+    addInlineElements(nextElements, stripLeadingLineBreak) {
+      stripAutomaticLineBreak(currentSegment, stripLeadingLineBreak);
       currentSegment.push(...nextElements);
     },
     addBlockElements(blockElements) {
@@ -4382,7 +5411,7 @@ function consumeCellContentNewline(ctx, startPos, content) {
     return { consumed };
   }
   if (!content.isEmpty()) {
-    content.addInline({ element: "line-break" });
+    content.addInline(createAutomaticLineBreak(ctx.tokens[startPos]));
   }
   return { consumed };
 }
@@ -4433,7 +5462,7 @@ function parseCellContent(ctx, closeCondition) {
     for (const rule of getCandidateInlineRules(ctx.inlineRules, token5.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        content.addInlineElements(result.elements);
+        content.addInlineElements(result.elements, result.stripLeadingLineBreak);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;
@@ -6853,7 +7882,7 @@ function resolveIfTags(data, pageTags) {
 // packages/parser/src/parser/preprocess/utils/raw-regions.ts
 var BASE_PLACEHOLDER_OPEN = "";
 var BASE_PLACEHOLDER_CLOSE = "";
-var RAW_BLOCK_OPEN_PATTERN = /\[\[\s*(code|html)\b[^\]]*\]\]/iy;
+var RAW_BLOCK_OPEN_PATTERN = /\[\[html\b[^\]]*\]\]/iy;
 function makeUniqueSentinels(source) {
   let openRun = 0;
   let closeRun = 0;
@@ -6872,10 +7901,21 @@ function makeUniqueSentinels(source) {
 }
 function maskRawRegions(source, sentinels) {
   const placeholders = [];
+  let tokens;
+  const getTokens = () => tokens ??= tokenize(source);
   let masked = "";
   let i = 0;
   while (i < source.length) {
-    const rawBlock = tryMaskRawBlock(source, i, placeholders, sentinels);
+    if (source.startsWith("[!--", i)) {
+      const close = source.indexOf("--]", i + 4);
+      if (close !== -1) {
+        const end = close + 3;
+        masked += source.slice(i, end);
+        i = end;
+        continue;
+      }
+    }
+    const rawBlock = tryMaskRawBlock(source, i, placeholders, sentinels, getTokens);
     if (rawBlock) {
       masked += rawBlock.placeholder;
       i = rawBlock.end;
@@ -6896,16 +7936,25 @@ function restorePlaceholders(source, placeholders, sentinels) {
   const pattern = new RegExp(`${escapeRegex(sentinels.open)}(\\d+)${escapeRegex(sentinels.close)}`, "g");
   return source.replace(pattern, (_, idx) => placeholders[Number(idx)] ?? "");
 }
-function tryMaskRawBlock(source, pos, placeholders, sentinels) {
+function tryMaskRawBlock(source, pos, placeholders, sentinels, getTokens) {
   if (source[pos] !== "[" || source[pos + 1] !== "[")
     return null;
+  if (source.slice(pos, pos + 6).toLowerCase() === "[[code") {
+    const tokens = getTokens();
+    const start = tokenAtOffset(tokens, pos);
+    const open = findCodeOpen(tokens, start);
+    if (!open)
+      return null;
+    const bounds = open.closingSwallowed ? null : findCodeBodyBounds(tokens, open.bodyStart);
+    const end = open.closingSwallowed ? tokens[open.attributesEnd - 1].position.end.offset : bounds.foundClose ? tokens[bounds.end - 1].position.end.offset : source.length;
+    return { placeholder: pushPlaceholder(placeholders, source.slice(pos, end), sentinels), end };
+  }
   RAW_BLOCK_OPEN_PATTERN.lastIndex = pos;
   const openMatch = RAW_BLOCK_OPEN_PATTERN.exec(source);
   if (!openMatch)
     return null;
-  const name = openMatch[1].toLowerCase();
   const openLen = openMatch[0].length;
-  const closePattern = new RegExp(`\\[\\[\\/\\s*${name}\\s*\\]\\]`, "ig");
+  const closePattern = /\[\[\/\s*html\s*\]\]/gi;
   closePattern.lastIndex = pos + openLen;
   const closeMatch = closePattern.exec(source);
   if (closeMatch) {
@@ -6915,12 +7964,19 @@ function tryMaskRawBlock(source, pos, placeholders, sentinels) {
       end
     };
   }
-  if (name !== "code")
-    return null;
-  return {
-    placeholder: pushPlaceholder(placeholders, source.slice(pos), sentinels),
-    end: source.length
-  };
+  return null;
+}
+function tokenAtOffset(tokens, offset) {
+  let low = 0;
+  let high = tokens.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (tokens[middle].position.start.offset < offset)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return tokens[low]?.position.start.offset === offset ? low : tokens.length;
 }
 function tryMaskRawInline(source, pos, placeholders, sentinels) {
   if (source[pos] === "@" && source[pos + 1] === "<") {
@@ -6932,17 +7988,22 @@ function tryMaskRawInline(source, pos, placeholders, sentinels) {
   return null;
 }
 function tryMaskSingleLineRaw(source, pos, openerLength, close, placeholders, sentinels) {
-  const closePos = source.indexOf(close, pos + openerLength);
-  const newline = source.indexOf(`
-`, pos + openerLength);
-  if (closePos === -1 || newline !== -1 && newline < closePos)
+  const end = singleLineRawEnd(source, pos, openerLength, close);
+  if (end === pos)
     return null;
-  const end = closePos + close.length;
   return {
     placeholder: pushPlaceholder(placeholders, source.slice(pos, end), sentinels),
     end
   };
 }
+function singleLineRawEnd(source, pos, openerLength, close) {
+  const closePos = source.indexOf(close, pos + openerLength);
+  const newline = source.indexOf(`
+`, pos + openerLength);
+  if (closePos === -1 || newline !== -1 && newline < closePos)
+    return pos;
+  return closePos + close.length;
+}
 function pushPlaceholder(placeholders, text, sentinels) {
   const idx = placeholders.length;
   placeholders.push(text);
@@ -9109,167 +10170,32 @@ function parseVariables(tokens) {
   for (const token5 of tokens) {
     if (token5 === "|") {
       assignVariable(vars, current2);
-      current2 = "";
-    } else {
-      current2 += token5;
-    }
-  }
-  assignVariable(vars, current2);
-  return vars;
-}
-function assignVariable(vars, source) {
-  if (!source.trim()) {
-    return;
-  }
-  const eqIndex = source.indexOf("=");
-  if (eqIndex === -1) {
-    return;
-  }
-  const key = source.slice(0, eqIndex).trim();
-  if (!key) {
-    return;
-  }
-  vars[key] = source.slice(eqIndex + 1).trim();
-}
-
-// packages/parser/src/parser/rules/block/include/index.ts
-var includeRule = {
-  name: "include",
-  startTokens: ["BLOCK_OPEN"],
-  requiresLineStart: false,
-  parse(ctx) {
-    const openToken = currentToken(ctx);
-    if (openToken.type !== "BLOCK_OPEN") {
-      return { success: false };
-    }
-    let pos = ctx.pos + 1;
-    let consumed = 1;
-    const nameResult = parseBlockName(ctx, pos);
-    if (!nameResult || nameResult.name.toLowerCase() !== "include") {
-      return { success: false };
-    }
-    if (!ctx.settings.enablePageSyntax) {
-      return { success: false };
-    }
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-    const args = collectIncludeArguments(ctx, pos);
-    pos += args.consumed;
-    consumed += args.consumed;
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-    const directiveEnd = pos;
-    if (ctx.tokens[pos]?.type === "NEWLINE") {
-      pos++;
-      consumed++;
-    }
-    if (!args.target) {
-      return { success: false };
-    }
-    const location = parsePageRef(args.target);
-    if (ctx.deferInclude?.(location)) {
-      const source = ctx.tokens.slice(ctx.pos, directiveEnd).map((token5) => token5.value).join("");
-      const elements = [];
-      const lines = source.split(`
-`);
-      for (let index = 0;index < lines.length; index++) {
-        if (index > 0)
-          elements.push(import_ast5.lineBreak());
-        if (lines[index] !== "")
-          elements.push(import_ast5.text(lines[index]));
-      }
-      return { success: true, elements: [import_ast5.paragraph(elements)], consumed };
-    }
-    return {
-      success: true,
-      elements: [
-        {
-          element: "include",
-          data: {
-            "paragraph-safe": false,
-            variables: parseVariables(args.argumentTokens),
-            location,
-            elements: []
-          }
-        }
-      ],
-      consumed
-    };
-  }
-};
-
-// packages/parser/src/parser/rules/block/math/content.ts
-function collectMathContent(ctx, startPos) {
-  let latexSource = "";
-  let pos = startPos;
-  let consumed = 0;
-  let foundClose = false;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5)
-      break;
-    if (token5.type === "BLOCK_END_OPEN") {
-      const closeNameResult = parseBlockName(ctx, pos + 1);
-      if (closeNameResult?.name === "math") {
-        foundClose = true;
-        break;
-      }
-    }
-    latexSource += token5.type === "BACKSLASH_BREAK" ? "\\\n" : token5.value;
-    pos++;
-    consumed++;
-  }
-  return { latexSource, consumed, foundClose };
-}
-function consumeMathClose(ctx, startPos) {
-  let pos = startPos + 1;
-  let consumed = 1;
-  const closeNameResult = parseBlockName(ctx, pos);
-  if (closeNameResult) {
-    pos += closeNameResult.consumed;
-    consumed += closeNameResult.consumed;
-  }
-  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
-    pos++;
-    consumed++;
-  }
-  if (ctx.tokens[pos]?.type === "NEWLINE") {
-    consumed++;
+      current2 = "";
+    } else {
+      current2 += token5;
+    }
   }
-  return consumed;
+  assignVariable(vars, current2);
+  return vars;
 }
-
-// packages/parser/src/parser/rules/block/math/name.ts
-function parseMathName(ctx, startPos) {
-  let pos = startPos;
-  let consumed = 0;
-  let name = "";
-  const first = ctx.tokens[pos];
-  if (first?.type !== "IDENTIFIER" && first?.type !== "TEXT") {
-    return { name: null, consumed: 0 };
+function assignVariable(vars, source) {
+  if (!source.trim()) {
+    return;
   }
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "BLOCK_CLOSE" || token5.type === "WHITESPACE" || token5.type === "NEWLINE") {
-      break;
-    }
-    name += token5.value;
-    pos++;
-    consumed++;
+  const eqIndex = source.indexOf("=");
+  if (eqIndex === -1) {
+    return;
+  }
+  const key = source.slice(0, eqIndex).trim();
+  if (!key) {
+    return;
   }
-  return { name: name === "" ? null : name, consumed };
+  vars[key] = source.slice(eqIndex + 1).trim();
 }
 
-// packages/parser/src/parser/rules/block/math/index.ts
-var mathBlockRule = {
-  name: "math",
+// packages/parser/src/parser/rules/block/include/index.ts
+var includeRule = {
+  name: "include",
   startTokens: ["BLOCK_OPEN"],
   requiresLineStart: false,
   parse(ctx) {
@@ -9280,7 +10206,10 @@ var mathBlockRule = {
     let pos = ctx.pos + 1;
     let consumed = 1;
     const nameResult = parseBlockName(ctx, pos);
-    if (!nameResult || nameResult.name !== "math") {
+    if (!nameResult || nameResult.name.toLowerCase() !== "include") {
+      return { success: false };
+    }
+    if (!ctx.settings.enablePageSyntax) {
       return { success: false };
     }
     pos += nameResult.consumed;
@@ -9289,49 +10218,46 @@ var mathBlockRule = {
       pos++;
       consumed++;
     }
-    const mathName = parseMathName(ctx, pos);
-    pos += mathName.consumed;
-    consumed += mathName.consumed;
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
+    const args = collectIncludeArguments(ctx, pos);
+    pos += args.consumed;
+    consumed += args.consumed;
     if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
       return { success: false };
     }
     pos++;
     consumed++;
+    const directiveEnd = pos;
     if (ctx.tokens[pos]?.type === "NEWLINE") {
       pos++;
       consumed++;
     }
-    const contentResult = collectMathContent(ctx, pos);
-    const latexSource = contentResult.latexSource.trim();
-    consumed += contentResult.consumed;
-    pos += contentResult.consumed;
-    if (!contentResult.foundClose) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: "Missing closing tag [[/math]] for [[math]]",
-        position: openToken.position
-      });
-    } else {
-      const closeConsumed = consumeMathClose(ctx, pos);
-      pos += closeConsumed;
-      consumed += closeConsumed;
-    }
-    if (!latexSource) {
+    if (!args.target) {
       return { success: false };
     }
+    const location = parsePageRef(args.target);
+    if (ctx.deferInclude?.(location)) {
+      const source = ctx.tokens.slice(ctx.pos, directiveEnd).map((token5) => token5.value).join("");
+      const elements = [];
+      const lines = source.split(`
+`);
+      for (let index = 0;index < lines.length; index++) {
+        if (index > 0)
+          elements.push(import_ast5.lineBreak());
+        if (lines[index] !== "")
+          elements.push(import_ast5.text(lines[index]));
+      }
+      return { success: true, elements: [import_ast5.paragraph(elements)], consumed };
+    }
     return {
       success: true,
       elements: [
         {
-          element: "math",
+          element: "include",
           data: {
-            name: mathName.name,
-            "latex-source": latexSource
+            "paragraph-safe": false,
+            variables: parseVariables(args.argumentTokens),
+            location,
+            elements: []
           }
         }
       ],
@@ -10201,7 +11127,8 @@ function parseBibliographyContent(ctx, startPos) {
     const inlineCtx = { ...ctx, pos };
     const result = parseInlineUntil(inlineCtx, "NEWLINE");
     if (result.elements.length > 0) {
-      content.push(...result.elements);
+      for (const element of result.elements)
+        content.push(element);
       pos += result.consumed;
       consumed += result.consumed;
     } else {
@@ -10630,6 +11557,7 @@ var blockRules = [
   iftagsRule,
   bibliographyRule,
   galleryRule,
+  noteRule,
   divRule
 ];
 // packages/parser/src/parser/rules/inline/formatting/close.ts
@@ -10642,6 +11570,11 @@ function findFormattingClose(ctx, start, marker) {
       return null;
     if (!table && token5.type === "NEWLINE" && getParagraphNewlineBoundary(ctx, pos, true).shouldBreak)
       return null;
+    const inlineRegionEnd = Math.max(emailRegionEnd(ctx.tokens, pos, end), parseButtonSyntax(ctx, pos, end)?.end ?? pos, parseSocialSyntax(ctx, pos, end)?.end ?? pos);
+    if (inlineRegionEnd > pos) {
+      pos = inlineRegionEnd - 1;
+      continue;
+    }
     if (token5.type === marker && !table?.suppressedClosers.has(pos))
       return pos;
     const protectedEnd = protectedInlineRegionEnd(ctx.tokens, pos, end);
@@ -10687,253 +11620,93 @@ function parseDelimitedContainer(ctx, closeToken, type, options = {}) {
       consumed
     };
   }
-  return {
-    success: true,
-    elements: [createInlineContainer(type, result.elements)],
-    consumed
-  };
-}
-
-// packages/parser/src/parser/rules/inline/bold.ts
-var boldRule = {
-  name: "bold",
-  startTokens: ["BOLD_MARKER"],
-  parse(ctx) {
-    return parseDelimitedContainer(ctx, "BOLD_MARKER", "bold", { discardEmpty: true });
-  }
-};
-
-// packages/parser/src/parser/rules/inline/italic.ts
-var italicRule = {
-  name: "italic",
-  startTokens: ["ITALIC_MARKER"],
-  parse(ctx) {
-    return parseDelimitedContainer(ctx, "ITALIC_MARKER", "italics");
-  }
-};
-
-// packages/parser/src/parser/rules/inline/underline/index.ts
-var underlineRule = {
-  name: "underline",
-  startTokens: ["UNDERLINE_MARKER"],
-  parse(ctx) {
-    return parseDelimitedContainer(ctx, "UNDERLINE_MARKER", "underline", { discardEmpty: true });
-  }
-};
-
-// packages/parser/src/parser/rules/inline/strikethrough/parse.ts
-function parseStrikethroughContent(ctx) {
-  return parseDelimitedContainer(ctx, "STRIKE_MARKER", "strikethrough");
-}
-
-// packages/parser/src/parser/rules/inline/strikethrough/syntax.ts
-function hasValidStrikethroughClose(ctx) {
-  const close = findFormattingClose(ctx, ctx.pos + 1, "STRIKE_MARKER");
-  return close !== null && close > ctx.pos + 1 && ctx.tokens[close - 1]?.type !== "WHITESPACE";
-}
-
-// packages/parser/src/parser/rules/inline/strikethrough/index.ts
-var strikethroughRule = {
-  name: "strikethrough",
-  startTokens: ["STRIKE_MARKER"],
-  parse(ctx) {
-    if (!hasValidStrikethroughClose(ctx)) {
-      return {
-        success: true,
-        elements: [{ element: "text", data: "—" }],
-        consumed: 1
-      };
-    }
-    return parseStrikethroughContent(ctx);
-  }
-};
-
-// packages/parser/src/parser/rules/inline/superscript.ts
-var superscriptRule = {
-  name: "superscript",
-  startTokens: ["SUPER_MARKER"],
-  parse(ctx) {
-    return parseDelimitedContainer(ctx, "SUPER_MARKER", "superscript", {
-      discardEmpty: true
-    });
-  }
-};
-
-// packages/parser/src/parser/rules/inline/subscript.ts
-var subscriptRule = {
-  name: "subscript",
-  startTokens: ["SUB_MARKER"],
-  parse(ctx) {
-    return parseDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
-  }
-};
-
-// packages/parser/src/parser/rules/inline/monospace.ts
-var monospaceRule = {
-  name: "monospace",
-  startTokens: ["MONO_MARKER"],
-  parse(ctx) {
-    return parseDelimitedContainer(ctx, "MONO_CLOSE", "monospace");
-  }
-};
-
-// packages/parser/src/parser/rules/inline/link-triple/fallback.ts
-function literalOpenLink(value) {
-  return {
-    success: true,
-    elements: [{ element: "text", data: value }],
-    consumed: 1
-  };
-}
-
-// packages/parser/src/parser/rules/inline/link-triple/label.ts
-function buildTripleLinkLabel(args) {
-  return {
-    text: getTripleLinkDisplayText(args)
-  };
-}
-function getTripleLinkDisplayText(args) {
-  const trimmedLabel = args.labelText.trim();
-  if (args.foundPipe) {
-    return trimmedLabel || args.finalTarget;
-  }
-  const colonIdx = args.originalTarget.indexOf(":");
-  if (colonIdx !== -1 && !args.originalTarget.startsWith("http") && !args.originalTarget.startsWith("*")) {
-    return args.originalTarget.slice(colonIdx + 1).trim();
-  }
-  return args.originalTarget;
-}
-
-// packages/parser/src/parser/rules/inline/link-triple/syntax.ts
-function hasClosingLinkMarker(ctx, startPos) {
-  let pos = startPos;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "EOF") {
-      return false;
-    }
-    if (token5.type === "LINK_CLOSE") {
-      return true;
-    }
-    if (token5.type === "NEWLINE") {
-      const next = ctx.tokens[pos + 1];
-      if (next?.type === "NEWLINE" || next?.type === "LINK_CLOSE") {
-        return false;
-      }
-    }
-    pos++;
-  }
-  return false;
-}
-function collectTripleLinkParts(ctx, startPos) {
-  let target = "";
-  let labelText = "";
-  let foundPipe = false;
-  let consumed = 1;
-  let pos = startPos;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "LINK_CLOSE" || token5.type === "EOF") {
-      break;
-    }
-    if (token5.type === "NEWLINE") {
-      if (foundPipe) {
-        labelText += " ";
-      } else {
-        target += " ";
-      }
-      consumed++;
-      pos++;
-      continue;
-    }
-    if (token5.type === "PIPE" && !foundPipe) {
-      foundPipe = true;
-    } else if (foundPipe) {
-      labelText += token5.value;
-    } else {
-      target += token5.value;
-    }
-    consumed++;
-    pos++;
-  }
-  if (ctx.tokens[pos]?.type === "LINK_CLOSE") {
-    consumed++;
-  }
-  return { target, labelText, foundPipe, consumed };
+  return {
+    success: true,
+    elements: [createInlineContainer(type, result.elements)],
+    consumed
+  };
 }
 
-// packages/parser/src/parser/rules/inline/link-triple/interwiki.ts
-var INTERWIKI_PREFIXES = new Set(["wikipedia", "google", "dictionary", "wikidot"]);
-function isInterwikiTarget(target) {
-  const colonIdx = target.indexOf(":");
-  if (colonIdx <= 0 || target.includes("/")) {
-    return false;
+// packages/parser/src/parser/rules/inline/bold.ts
+var boldRule = {
+  name: "bold",
+  startTokens: ["BOLD_MARKER"],
+  parse(ctx) {
+    return parseDelimitedContainer(ctx, "BOLD_MARKER", "bold", { discardEmpty: true });
   }
-  const prefix = target.slice(0, colonIdx).toLowerCase();
-  return INTERWIKI_PREFIXES.has(prefix);
-}
+};
 
-// packages/parser/src/parser/rules/inline/link-triple/target.ts
-function normalizeTripleLinkTarget(trimmedTarget) {
-  if (trimmedTarget.startsWith("*")) {
-    return { target: trimmedTarget.slice(1), hasStar: true };
+// packages/parser/src/parser/rules/inline/italic.ts
+var italicRule = {
+  name: "italic",
+  startTokens: ["ITALIC_MARKER"],
+  parse(ctx) {
+    return parseDelimitedContainer(ctx, "ITALIC_MARKER", "italics");
   }
-  return { target: trimmedTarget, hasStar: false };
+};
+
+// packages/parser/src/parser/rules/inline/underline/index.ts
+var underlineRule = {
+  name: "underline",
+  startTokens: ["UNDERLINE_MARKER"],
+  parse(ctx) {
+    return parseDelimitedContainer(ctx, "UNDERLINE_MARKER", "underline", { discardEmpty: true });
+  }
+};
+
+// packages/parser/src/parser/rules/inline/strikethrough/parse.ts
+function parseStrikethroughContent(ctx) {
+  return parseDelimitedContainer(ctx, "STRIKE_MARKER", "strikethrough");
 }
-function isInvalidTripleLinkTarget(trimmedTarget, foundPipe) {
-  return trimmedTarget === "" && foundPipe || /#{2,}/.test(trimmedTarget);
+
+// packages/parser/src/parser/rules/inline/strikethrough/syntax.ts
+function hasValidStrikethroughClose(ctx) {
+  const close = findFormattingClose(ctx, ctx.pos + 1, "STRIKE_MARKER");
+  return close !== null && close > ctx.pos + 1 && ctx.tokens[close - 1]?.type !== "WHITESPACE";
 }
-function determineLinkTypeAndLocation(target) {
-  if (target.startsWith("#")) {
-    return { linkType: "anchor", link: target };
+
+// packages/parser/src/parser/rules/inline/strikethrough/index.ts
+var strikethroughRule = {
+  name: "strikethrough",
+  startTokens: ["STRIKE_MARKER"],
+  parse(ctx) {
+    if (!hasValidStrikethroughClose(ctx)) {
+      return {
+        success: true,
+        elements: [{ element: "text", data: "—" }],
+        consumed: 1
+      };
+    }
+    return parseStrikethroughContent(ctx);
   }
-  if (target.startsWith("http://") || target.startsWith("https://")) {
-    return { linkType: "direct", link: target };
+};
+
+// packages/parser/src/parser/rules/inline/superscript.ts
+var superscriptRule = {
+  name: "superscript",
+  startTokens: ["SUPER_MARKER"],
+  parse(ctx) {
+    return parseDelimitedContainer(ctx, "SUPER_MARKER", "superscript", {
+      discardEmpty: true
+    });
   }
-  if (isInterwikiTarget(target)) {
-    return { linkType: "interwiki", link: target };
+};
+
+// packages/parser/src/parser/rules/inline/subscript.ts
+var subscriptRule = {
+  name: "subscript",
+  startTokens: ["SUB_MARKER"],
+  parse(ctx) {
+    return parseDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
   }
-  return { linkType: "page", link: { site: null, page: target } };
-}
+};
 
-// packages/parser/src/parser/rules/inline/link-triple/index.ts
-var linkTripleRule = {
-  name: "linkTriple",
-  startTokens: ["LINK_OPEN"],
+// packages/parser/src/parser/rules/inline/monospace.ts
+var monospaceRule = {
+  name: "monospace",
+  startTokens: ["MONO_MARKER"],
   parse(ctx) {
-    const startToken = currentToken(ctx);
-    if (!hasClosingLinkMarker(ctx, ctx.pos + 1)) {
-      return literalOpenLink(startToken.value);
-    }
-    const parts = collectTripleLinkParts(ctx, ctx.pos + 1);
-    const trimmedTarget = parts.target.trim();
-    if (isInvalidTripleLinkTarget(trimmedTarget, parts.foundPipe)) {
-      return literalOpenLink(startToken.value);
-    }
-    const normalized = normalizeTripleLinkTarget(trimmedTarget);
-    const { linkType, link } = determineLinkTypeAndLocation(normalized.target);
-    const label = buildTripleLinkLabel({
-      foundPipe: parts.foundPipe,
-      labelText: parts.labelText,
-      finalTarget: normalized.target,
-      originalTarget: trimmedTarget
-    });
-    return {
-      success: true,
-      elements: [
-        {
-          element: "link",
-          data: {
-            type: linkType,
-            link,
-            extra: null,
-            label,
-            target: normalized.hasStar && linkType === "direct" ? "new-tab" : null
-          }
-        }
-      ],
-      consumed: parts.consumed
-    };
+    return parseDelimitedContainer(ctx, "MONO_CLOSE", "monospace");
   }
 };
 
@@ -10944,7 +11717,7 @@ function normalizeAnchor(anchor) {
 
 // packages/parser/src/parser/rules/inline/link-bracket/direct-url.ts
 function isDirectBracketUrl(url) {
-  return url !== "" && (url.startsWith("/") || url.startsWith("http://") || url.startsWith("https://"));
+  return url !== "" && (url.startsWith("/") || startsWithUrlScheme(url, 0));
 }
 
 // packages/parser/src/parser/rules/inline/link-bracket/parts.ts
@@ -10953,35 +11726,24 @@ function collectBracketLinkParts(ctx, startPos) {
     return null;
   }
   let pos = startPos;
-  let consumed = 0;
-  let first = "";
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "WHITESPACE" || token5.type === "BRACKET_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF") {
-      break;
-    }
-    first += token5.value;
-    pos++;
-    consumed++;
-  }
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-  let label = "";
-  while (pos < ctx.tokens.length) {
+  const end = Math.min(ctx.scope.inlineEnd ?? ctx.tokens.length, ctx.tokens.length);
+  const values = [];
+  while (pos < end) {
     const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "BRACKET_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF") {
+    if (!token5 || token5.type === "BRACKET_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF")
       break;
-    }
-    label += token5.value;
+    values.push(token5.value);
     pos++;
-    consumed++;
   }
-  if (ctx.tokens[pos]?.type !== "BRACKET_CLOSE") {
+  if (pos >= end || ctx.tokens[pos]?.type !== "BRACKET_CLOSE")
     return null;
-  }
-  return { first, label, consumed: consumed + 1 };
+  const content = values.join("");
+  const separator = content.search(/[ \t]/);
+  return {
+    first: separator === -1 ? content : content.slice(0, separator),
+    label: separator === -1 ? "" : content.slice(separator).trimStart(),
+    consumed: pos - startPos + 1
+  };
 }
 
 // packages/parser/src/parser/rules/inline/link-bracket/prefix.ts
@@ -10992,6 +11754,14 @@ function parseBracketLinkPrefix(ctx, startPos) {
   return { target: null, bodyStart: startPos, consumed: 0 };
 }
 
+// packages/parser/src/parser/rules/inline/link-bracket/special-target.ts
+function isBracketEmail(target) {
+  return /^[_a-z0-9-]+(?:\.[_a-z0-9-]+)*@[a-z0-9-]+(?:\.[a-z0-9-]+)+$/i.test(target);
+}
+function wikipediaPage(target) {
+  return /^wikipedia:((?!:)[A-Za-z0-9_/=&~#.:;+-]+)$/.exec(target)?.[1] ?? null;
+}
+
 // packages/parser/src/parser/rules/inline/link-bracket/parsed.ts
 function parseSingleBracketLink(ctx) {
   const prefix = parseBracketLinkPrefix(ctx, ctx.pos + 1);
@@ -11000,17 +11770,20 @@ function parseSingleBracketLink(ctx) {
     return null;
   }
   const link = parts.first.trim();
-  if (!isDirectBracketUrl(link)) {
+  const email = isBracketEmail(link);
+  const wikiPage = wikipediaPage(link);
+  if (!email && wikiPage === null && !isDirectBracketUrl(link)) {
     return null;
   }
-  const labelText = parts.label.trim();
+  const labelText = parts.label.trim() || wikiPage;
   if (!labelText) {
     return null;
   }
   return {
-    link,
+    link: email ? `mailto:${link}` : link,
+    interwiki: wikiPage !== null,
     labelText,
-    target: prefix.target,
+    target: wikiPage !== null ? "new-tab" : prefix.target,
     consumed: 1 + prefix.consumed + parts.consumed
   };
 }
@@ -11063,7 +11836,7 @@ var linkSingleRule = {
         {
           element: "link",
           data: {
-            type: "direct",
+            type: parsed.interwiki ? "interwiki" : "direct",
             link: parsed.link,
             extra: null,
             label: linkLabel,
@@ -11132,6 +11905,134 @@ var linkStarRule = {
   }
 };
 
+// packages/parser/src/parser/rules/inline/autolink.ts
+var URL_BOUNDARY_TOKENS = new Set([
+  "WHITESPACE",
+  "NEWLINE",
+  "EOF",
+  "BLOCK_OPEN",
+  "BLOCK_END_OPEN",
+  "BLOCK_CLOSE",
+  "LINK_OPEN",
+  "LINK_CLOSE",
+  "COMMENT_OPEN",
+  "BACKSLASH_BREAK"
+]);
+var autolinkRule = {
+  name: "autolink",
+  startTokens: ["IDENTIFIER", "STAR", "LIST_BULLET"],
+  parse(ctx) {
+    let pos = ctx.pos;
+    let target = null;
+    const first = ctx.tokens[pos];
+    if (!first) {
+      return { success: false };
+    }
+    if (first.type === "STAR" || first.type === "LIST_BULLET") {
+      if (first.value !== "*") {
+        return { success: false };
+      }
+      target = "new-tab";
+      pos++;
+    }
+    const scheme = ctx.tokens[pos];
+    if (scheme?.type !== "IDENTIFIER" || !URL_SCHEME_NAMES.has(scheme.value)) {
+      return { success: false };
+    }
+    if (ctx.tokens[pos + 1]?.type !== "COLON") {
+      return { success: false };
+    }
+    const prev = ctx.tokens[ctx.pos - 1];
+    if (prev && !first.lineStart) {
+      const lastChar = prev.value[prev.value.length - 1] ?? "";
+      if (/[A-Za-z]/.test(lastChar)) {
+        return { success: false };
+      }
+    }
+    const values = [];
+    let end = pos;
+    const inlineEnd = ctx.scope.inlineEnd ?? ctx.tokens.length;
+    while (end < inlineEnd) {
+      const token5 = ctx.tokens[end];
+      if (!token5 || URL_BOUNDARY_TOKENS.has(token5.type)) {
+        break;
+      }
+      if (token5.type === "RAW_OPEN" || token5.type === "RAW_BLOCK_OPEN") {
+        if (rawRegionEnd(ctx.tokens, end, inlineEnd) > end)
+          break;
+      }
+      values.push(token5.value);
+      end++;
+      if (/[ \t\n\\"']/.test(token5.value))
+        break;
+    }
+    const candidate = values.join("");
+    const match = URL_PATTERN.exec(candidate);
+    if (!match) {
+      return { success: false };
+    }
+    const url = match[0];
+    let length = 0;
+    let count = 0;
+    while (length < url.length) {
+      length += values[count]?.length ?? 0;
+      count++;
+    }
+    const rest = candidate.slice(url.length, length);
+    const elements = [
+      {
+        element: "link",
+        data: {
+          type: "direct",
+          link: url,
+          extra: null,
+          label: { text: url },
+          target
+        }
+      }
+    ];
+    if (rest !== "") {
+      elements.push({ element: "text", data: rest });
+    }
+    return {
+      success: true,
+      elements,
+      consumed: pos - ctx.pos + count
+    };
+  }
+};
+
+// packages/parser/src/parser/rules/inline/email/index.ts
+var emailRule = {
+  name: "email",
+  startTokens: EMAIL_START_TOKENS,
+  parse(ctx) {
+    const group = getEmailGroup(ctx.tokens, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    if (!group)
+      return { success: false };
+    const elements = [];
+    let copied = group.start;
+    for (const candidate of group.candidates) {
+      if (copied < candidate.start)
+        elements.push({ element: "text", data: group.source.slice(copied, candidate.start) });
+      elements.push(ctx.scope.suppressEmailLinks ? { element: "text", data: candidate.address } : {
+        element: "link",
+        data: {
+          type: "direct",
+          link: `mailto:${candidate.address}`,
+          label: { text: candidate.address },
+          target: null,
+          extra: null
+        }
+      });
+      copied = candidate.end;
+    }
+    if (copied < group.end)
+      elements.push({ element: "text", data: group.source.slice(copied, group.end) });
+    return { success: true, elements, consumed: group.endToken - ctx.pos };
+  }
+};
+
 // packages/parser/src/parser/rules/inline/color/syntax.ts
 function parseColorContent(ctx) {
   const close = findFormattingClose(ctx, ctx.pos + 1, "COLOR_MARKER");
@@ -11218,7 +12119,7 @@ var newlineLineBreakRule = {
     }
     return {
       success: true,
-      elements: [{ element: "line-break" }],
+      elements: [createAutomaticLineBreak(currentTok)],
       consumed: 1
     };
   }
@@ -11241,6 +12142,9 @@ function isValidBlockStartAfterNewline(ctx, tokenPos) {
   if (!isBlockStartToken(token5?.type) || !token5?.lineStart) {
     return false;
   }
+  if (token5.type === "LIST_BULLET" || token5.type === "LIST_NUMBER") {
+    return ctx.tokens[tokenPos + 1]?.type === "WHITESPACE";
+  }
   if (token5.type !== "HEADING_MARKER") {
     return true;
   }
@@ -11498,6 +12402,9 @@ var htmlInlineRule = {
   }
 };
 
+// packages/parser/src/parser/rules/inline/raw/angle.ts
+var import_entities = require("entities");
+
 // packages/parser/src/parser/rules/inline/raw/result.ts
 function rawElement(value, consumed) {
   return {
@@ -11545,7 +12452,7 @@ function parseAngleRaw(ctx) {
   if (ctx.tokens[pos]?.type === "RAW_BLOCK_CLOSE") {
     consumed++;
   }
-  return rawElement(value, consumed);
+  return rawElement(import_entities.decodeHTML(value), consumed);
 }
 
 // packages/parser/src/parser/rules/inline/raw/double-at.ts
@@ -11768,7 +12675,7 @@ function consumeSpanNewline(ctx, pos, paragraphStrip, afterBlankLine, children,
     return { consumed: consumed2, afterBlankLine: paragraphStrip };
   }
   const targetChildren = paragraphStrip && afterBlankLine ? escapedChildren : children;
-  targetChildren.push({ element: "line-break" });
+  targetChildren.push(createAutomaticLineBreak(ctx.tokens[pos]));
   let consumed = 1;
   let nextPos = pos + 1;
   while (ctx.tokens[nextPos]?.type === "WHITESPACE" && ctx.tokens[nextPos]?.lineStart) {
@@ -11856,7 +12763,9 @@ function parseOneSpanChild(ctx, pos, targetChildren) {
   for (const rule of getCandidateInlineRules(inlineRules, token5.type)) {
     const result = rule.parse(inlineCtx);
     if (result.success) {
-      targetChildren.push(...result.elements);
+      stripAutomaticLineBreak(targetChildren, result.stripLeadingLineBreak);
+      for (const element of result.elements)
+        targetChildren.push(element);
       return { consumed: result.consumed };
     }
   }
@@ -11924,6 +12833,48 @@ var closeSpanRule = {
   }
 };
 
+// packages/parser/src/parser/rules/inline/button/index.ts
+var buttonRule = {
+  name: "button",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const result = parseButtonSyntax(ctx, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    return result ? {
+      success: true,
+      consumed: result.end - ctx.pos,
+      elements: [{ element: "button", data: result.data }]
+    } : { success: false };
+  }
+};
+
+// packages/parser/src/parser/rules/inline/social/index.ts
+var socialRule = {
+  name: "social",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const result = parseSocialSyntax(ctx, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    return result ? {
+      success: true,
+      consumed: result.end - ctx.pos,
+      elements: [{ element: "social", data: result.data }]
+    } : { success: false };
+  }
+};
+
+// packages/parser/src/parser/rules/inline/date/index.ts
+var dateRule = {
+  name: "date",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const parsed = parseDateSyntax(ctx, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    return parsed ? {
+      success: true,
+      consumed: parsed.end - ctx.pos,
+      elements: [{ element: "date", data: parsed.data }]
+    } : { success: false };
+  }
+};
+
 // packages/parser/src/parser/rules/inline/size/content.ts
 function parseSizeContent(ctx, startPos) {
   const children = [];
@@ -11945,7 +12896,8 @@ function parseSizeContent(ctx, startPos) {
     const inlineCtx = { ...ctx, pos };
     const inlineResult = parseInlineUntil(inlineCtx, "BLOCK_END_OPEN");
     if (inlineResult.elements.length > 0) {
-      children.push(...inlineResult.elements);
+      for (const element of inlineResult.elements)
+        children.push(element);
       pos += inlineResult.consumed;
       consumed += inlineResult.consumed;
     } else {
@@ -11974,6 +12926,16 @@ function tryConsumeSizeClose(ctx, pos) {
 
 // packages/parser/src/parser/rules/inline/size/value.ts
 var VALID_SIZE_UNITS = ["px", "em", "rem", "ex", "%", "cm", "mm", "in", "pc"];
+var VALID_SIZE_KEYWORDS = [
+  "smaller",
+  "larger",
+  "xx-small",
+  "x-small",
+  "small",
+  "large",
+  "x-large",
+  "xx-large"
+];
 function parseSizeValue(ctx, startPos) {
   let pos = startPos;
   let consumed = 0;
@@ -11998,6 +12960,8 @@ function parseSizeValue(ctx, startPos) {
   return isValidSizeValue(size) ? { size, consumed } : null;
 }
 function isValidSizeValue(size) {
+  if (VALID_SIZE_KEYWORDS.includes(size))
+    return true;
   const unitPattern = VALID_SIZE_UNITS.join("|");
   return new RegExp(`^(\\d+(?:\\.\\d+)?)(${unitPattern})$`, "i").test(size);
 }
@@ -12069,19 +13033,6 @@ var sizeRule = {
   }
 };
 
-// packages/parser/src/parser/rules/inline/footnote/child.ts
-function parseFootnoteChild(ctx, pos) {
-  const token5 = ctx.tokens[pos];
-  if (!token5) {
-    return { elements: [], consumed: 0 };
-  }
-  const inlineResult = parseInlineUntil({ ...ctx, pos }, "BLOCK_END_OPEN");
-  if (inlineResult.elements.length > 0) {
-    return { elements: inlineResult.elements, consumed: inlineResult.consumed };
-  }
-  return { elements: [{ element: "text", data: token5.value }], consumed: 1 };
-}
-
 // packages/parser/src/parser/rules/inline/footnote/close.ts
 function tryConsumeFootnoteClose(ctx, pos) {
   if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
@@ -12103,96 +13054,73 @@ function tryConsumeFootnoteClose(ctx, pos) {
   return { consumed };
 }
 
-// packages/parser/src/parser/rules/inline/footnote/newline.ts
-function consumeFootnoteNewline(ctx, pos) {
-  let nextPos = pos + 1;
-  let consumed = 1;
-  while (ctx.tokens[nextPos]?.type === "WHITESPACE") {
-    nextPos++;
-    consumed++;
-  }
-  if (ctx.tokens[nextPos]?.type !== "NEWLINE") {
-    return { consumed, paragraphBreak: false };
+// packages/parser/src/parser/rules/inline/math-inline/syntax.ts
+function parseInlineMathSource(ctx, startPos) {
+  let pos = startPos;
+  let consumed = 0;
+  if (ctx.tokens[pos]?.type !== "TEXT" || ctx.tokens[pos]?.value !== "$") {
+    return null;
   }
-  while (ctx.tokens[nextPos]?.type === "NEWLINE") {
-    nextPos++;
+  pos++;
+  consumed++;
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
     consumed++;
   }
-  return { consumed, paragraphBreak: true };
-}
-
-// packages/parser/src/parser/rules/inline/footnote/content.ts
-function parseFootnoteContent(ctx, startPos) {
-  const paragraphs = [[]];
-  let currentParagraph = 0;
-  let pos = startPos;
-  let consumed = 0;
+  let latexSource = "";
   while (pos < ctx.tokens.length) {
     const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "EOF") {
-      break;
-    }
-    const closeResult = tryConsumeFootnoteClose(ctx, pos);
-    if (closeResult) {
-      return {
-        paragraphs,
-        consumed: consumed + closeResult.consumed,
-        foundClose: true
-      };
+    if (!token5 || token5.type === "NEWLINE") {
+      return null;
     }
-    if (token5.type === "NEWLINE") {
-      const newlineResult = consumeFootnoteNewline(ctx, pos);
-      pos += newlineResult.consumed;
-      consumed += newlineResult.consumed;
-      if (newlineResult.paragraphBreak) {
-        currentParagraph++;
-        paragraphs[currentParagraph] = [];
-      } else {
-        paragraphs[currentParagraph].push({ element: "line-break" });
-      }
-      continue;
+    if (token5.type === "TEXT" && token5.value === "$" && ctx.tokens[pos + 1]?.type === "BLOCK_CLOSE") {
+      break;
     }
-    const child = parseFootnoteChild(ctx, pos);
-    paragraphs[currentParagraph].push(...child.elements);
-    pos += child.consumed;
-    consumed += child.consumed;
+    latexSource += token5.value;
+    pos++;
+    consumed++;
+  }
+  if (ctx.tokens[pos]?.type !== "TEXT" || ctx.tokens[pos]?.value !== "$") {
+    return null;
+  }
+  pos++;
+  consumed++;
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
   }
-  return { paragraphs, consumed, foundClose: false };
+  return {
+    latexSource: latexSource.trim(),
+    consumed: consumed + 1
+  };
 }
 
-// packages/parser/src/parser/rules/inline/footnote/elements.ts
-function buildFootnoteChildren(paragraphs) {
-  const children = [];
-  for (let i = 0;i < paragraphs.length; i++) {
-    const para = trimLineBreaks(paragraphs[i] ?? []);
-    if (para.length === 0) {
-      continue;
+// packages/parser/src/parser/rules/inline/math-inline/index.ts
+var mathInlineRule = {
+  name: "math-inline",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
     }
-    if (i === 0) {
-      children.push(...para);
-    } else {
-      children.push({
-        element: "container",
-        data: {
-          type: "paragraph",
-          attributes: {},
-          elements: para
-        }
-      });
+    const parsed = parseInlineMathSource(ctx, ctx.pos + 1);
+    if (!parsed) {
+      return { success: false };
     }
+    return {
+      success: true,
+      elements: [
+        {
+          element: "math-inline",
+          data: {
+            "latex-source": parsed.latexSource
+          }
+        }
+      ],
+      consumed: 1 + parsed.consumed
+    };
   }
-  return children;
-}
-function trimLineBreaks(elements) {
-  const result = [...elements];
-  while (result.length > 0 && result[0]?.element === "line-break") {
-    result.shift();
-  }
-  while (result.length > 0 && result[result.length - 1]?.element === "line-break") {
-    result.pop();
-  }
-  return result;
-}
+};
 
 // packages/parser/src/parser/rules/inline/footnote/open.ts
 function parseFootnoteOpen(ctx) {
@@ -12219,6 +13147,91 @@ function parseFootnoteOpen(ctx) {
   return { bodyStart: pos, consumed };
 }
 
+// packages/parser/src/parser/rules/inline/footnote/boundary.ts
+var opaqueRules2 = [
+  codeBlockRule,
+  htmlBlockRule,
+  mathBlockRule,
+  mathInlineRule,
+  linkTripleRule,
+  linkSingleRule,
+  linkStarRule,
+  linkAnchorRule
+];
+function findFootnoteEnd(ctx, start) {
+  const probe = createOpaqueProbe(ctx);
+  let depth = 0;
+  for (let pos = start;pos < ctx.tokens.length; pos++) {
+    if (ctx.tokens[pos]?.type === "EOF")
+      return pos;
+    const protectedEnd = protectedInlineRegionEnd(ctx.tokens, pos, ctx.tokens.length);
+    if (protectedEnd > pos) {
+      pos = protectedEnd - 1;
+      continue;
+    }
+    probe.pos = pos;
+    const close = tryConsumeFootnoteClose(probe, pos);
+    if (close) {
+      if (depth === 0)
+        return pos;
+      depth--;
+      pos += close.consumed - 1;
+      continue;
+    }
+    const open = parseFootnoteOpen(probe);
+    if (open) {
+      depth++;
+      pos += open.consumed - 1;
+      continue;
+    }
+    const opaqueEnd = opaqueRuleEnd(probe, pos, opaqueRules2);
+    if (opaqueEnd > pos)
+      pos = opaqueEnd - 1;
+  }
+  return ctx.tokens.length;
+}
+
+// packages/parser/src/parser/rules/inline/footnote/content.ts
+function parseFootnoteContent(ctx, startPos) {
+  const end = findFootnoteEnd(ctx, startPos);
+  let leadingNewlines = 0;
+  for (let pos = startPos;pos < end; pos++) {
+    const type = ctx.tokens[pos]?.type;
+    if (type === "NEWLINE")
+      leadingNewlines++;
+    else if (type !== "WHITESPACE")
+      break;
+  }
+  const bodyCtx = {
+    ...ctx,
+    tokens: ctx.tokens.slice(startPos, end),
+    pos: 0,
+    scope: {
+      ...ctx.scope,
+      inlineEnd: undefined,
+      tableFormatting: undefined,
+      blockCloseCondition: undefined
+    }
+  };
+  const result = parseBlocksUntil(bodyCtx, () => false);
+  const close = tryConsumeFootnoteClose(ctx, end);
+  return {
+    elements: result.elements,
+    consumed: end - startPos + (close?.consumed ?? 0),
+    foundClose: close !== null,
+    leadingParagraphBreak: leadingNewlines >= 2
+  };
+}
+
+// packages/parser/src/parser/rules/inline/footnote/elements.ts
+function buildFootnoteChildren(elements, leadingParagraphBreak) {
+  const first = elements[0];
+  if (!leadingParagraphBreak && first?.element === "container" && first.data.type === "paragraph") {
+    return [...first.data.elements, ...elements.slice(1)];
+  }
+  return elements;
+}
+
 // packages/parser/src/parser/rules/inline/footnote/index.ts
 var footnoteRule = {
   name: "footnote",
@@ -12234,7 +13247,7 @@ var footnoteRule = {
     }
     const contentResult = parseFootnoteContent(ctx, openResult.bodyStart);
     const consumed = openResult.consumed + contentResult.consumed;
-    const children = buildFootnoteChildren(contentResult.paragraphs);
+    const children = buildFootnoteChildren(contentResult.elements, contentResult.leadingParagraphBreak);
     if (!contentResult.foundClose) {
       ctx.diagnostics.push({
         severity: "warning",
@@ -12594,11 +13607,15 @@ function parseAnchorChild(ctx, pos) {
   if (!token5) {
     return { elements: [], consumed: 0 };
   }
-  const inlineCtx = { ...ctx, pos };
+  const inlineCtx = {
+    ...ctx,
+    pos,
+    scope: { ...ctx.scope, suppressEmailLinks: true }
+  };
   for (const rule of getCandidateInlineRules(inlineRules, token5.type)) {
     const result = rule.parse(inlineCtx);
     if (result.success) {
-      return { elements: result.elements, consumed: result.consumed };
+      return result;
     }
   }
   return { elements: [{ element: "text", data: token5.value }], consumed: 1 };
@@ -12658,7 +13675,7 @@ function consumeAnchorNewline(ctx, pos, paragraphStrip, children) {
   let consumed = 1;
   let nextPos = pos + 1;
   if (!paragraphStrip) {
-    children.push({ element: "line-break" });
+    children.push(createAutomaticLineBreak(ctx.tokens[pos]));
     while (ctx.tokens[nextPos]?.type === "WHITESPACE" && ctx.tokens[nextPos]?.lineStart) {
       nextPos++;
       consumed++;
@@ -12711,7 +13728,9 @@ function parseAnchorContent(ctx, startPos, paragraphStrip) {
       continue;
     }
     const child = parseAnchorChild(ctx, pos);
-    children.push(...child.elements);
+    stripAutomaticLineBreak(children, child.stripLeadingLineBreak);
+    for (const element of child.elements)
+      children.push(element);
     pos += child.consumed;
     consumed += child.consumed;
   }
@@ -12785,75 +13804,8 @@ var anchorRule = {
           }
         }
       ],
-      consumed
-    };
-  }
-};
-
-// packages/parser/src/parser/rules/inline/math-inline/syntax.ts
-function parseInlineMathSource(ctx, startPos) {
-  let pos = startPos;
-  let consumed = 0;
-  if (ctx.tokens[pos]?.type !== "TEXT" || ctx.tokens[pos]?.value !== "$") {
-    return null;
-  }
-  pos++;
-  consumed++;
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-  let latexSource = "";
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "NEWLINE") {
-      return null;
-    }
-    if (token5.type === "TEXT" && token5.value === "$" && ctx.tokens[pos + 1]?.type === "BLOCK_CLOSE") {
-      break;
-    }
-    latexSource += token5.value;
-    pos++;
-    consumed++;
-  }
-  if (ctx.tokens[pos]?.type !== "TEXT" || ctx.tokens[pos]?.value !== "$") {
-    return null;
-  }
-  pos++;
-  consumed++;
-  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-    return null;
-  }
-  return {
-    latexSource: latexSource.trim(),
-    consumed: consumed + 1
-  };
-}
-
-// packages/parser/src/parser/rules/inline/math-inline/index.ts
-var mathInlineRule = {
-  name: "math-inline",
-  startTokens: ["BLOCK_OPEN"],
-  parse(ctx) {
-    const openToken = currentToken(ctx);
-    if (openToken.type !== "BLOCK_OPEN") {
-      return { success: false };
-    }
-    const parsed = parseInlineMathSource(ctx, ctx.pos + 1);
-    if (!parsed) {
-      return { success: false };
-    }
-    return {
-      success: true,
-      elements: [
-        {
-          element: "math-inline",
-          data: {
-            "latex-source": parsed.latexSource
-          }
-        }
-      ],
-      consumed: 1 + parsed.consumed
+      consumed,
+      stripLeadingLineBreak: openResult.paragraphStrip ? precedingSingleNewline(ctx) : undefined
     };
   }
 };
@@ -12964,7 +13916,9 @@ function parseInlineBranch(ctx, startPos) {
       }
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        elements.push(...result.elements);
+        stripAutomaticLineBreak(elements, result.stripLeadingLineBreak);
+        for (const element of result.elements)
+          elements.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;
@@ -13287,6 +14241,7 @@ var textRule = {
 
 // packages/parser/src/parser/rules/inline/index.ts
 var inlineRules = [
+  emailRule,
   boldRule,
   italicRule,
   underlineRule,
@@ -13298,6 +14253,7 @@ var inlineRules = [
   linkSingleRule,
   linkAnchorRule,
   linkStarRule,
+  autolinkRule,
   colorRule,
   backslashLineBreakRule,
   underscoreLineBreakRule,
@@ -13307,6 +14263,9 @@ var inlineRules = [
   rawRule,
   imageRule,
   embedBlockRule,
+  buttonRule,
+  socialRule,
+  dateRule,
   sizeRule,
   footnoteRule,
   spanRule,
@@ -13562,6 +14521,8 @@ function mergeSpanStripParagraphs(children) {
       i++;
       continue;
     }
+    const firstMeaningful = paraData.elements.find((child) => child.element !== "line-break" && !isWhitespaceText(child));
+    const keepParagraph = firstMeaningful && !isSpanStripMarker(firstMeaningful);
     const mergedChildren = [...paraData.elements];
     i++;
     while (i < expandedChildren.length) {
@@ -13574,7 +14535,8 @@ function mergeSpanStripParagraphs(children) {
         break;
       }
       const hasSpanStrip = hasParagraphStripSpan(nextPara);
-      mergedChildren.push(...nextParaData.elements);
+      for (const element of nextParaData.elements)
+        mergedChildren.push(element);
       i++;
       if (!hasSpanStrip) {
         const peekNext = expandedChildren[i];
@@ -13585,7 +14547,7 @@ function mergeSpanStripParagraphs(children) {
     }
     const escapedSpans = extractEscapedSpans(mergedChildren);
     removeLineBreaksAroundSpanStrip(mergedChildren);
-    if (escapedSpans.length > 0) {
+    if (escapedSpans.length > 0 || keepParagraph) {
       if (mergedChildren.length > 0) {
         result.push(paragraphElement(mergedChildren));
       }
@@ -13806,50 +14768,6 @@ function cleanInternalFlags(elements) {
   }
   return removeEmptySpansAndAdjacentWhitespace(cleaned ?? elements);
 }
-// packages/parser/src/parser/postprocess/divAdjacentParagraph.ts
-function isParagraphContainer2(el) {
-  if (!el || el.element !== "container")
-    return false;
-  return el.data.type === "paragraph";
-}
-function isDivContainer(el) {
-  if (!el || el.element !== "container")
-    return false;
-  return el.data.type === "div";
-}
-function suppressAtLevel(elements) {
-  if (elements.length <= 1)
-    return elements;
-  const unwrap = Array.from({ length: elements.length }, () => false);
-  for (let i = 0;i < elements.length; i++) {
-    if (!isParagraphContainer2(elements[i]))
-      continue;
-    const prevIsDiv = i > 0 && isDivContainer(elements[i - 1]);
-    const nextIsDiv = i < elements.length - 1 && isDivContainer(elements[i + 1]);
-    if (prevIsDiv || nextIsDiv) {
-      unwrap[i] = true;
-    }
-  }
-  const result = [];
-  for (let i = 0;i < elements.length; i++) {
-    const el = elements[i];
-    if (!el)
-      continue;
-    if (unwrap[i] && el.element === "container") {
-      const inner = el.data.elements;
-      if (i > 0 && isDivContainer(elements[i - 1])) {
-        result.push({ element: "line-break" });
-      }
-      result.push(...inner);
-    } else {
-      result.push(el);
-    }
-  }
-  return result;
-}
-function suppressDivAdjacentParagraphs(elements) {
-  return suppressAtLevel(elements);
-}
 // packages/parser/src/parser/parse/footnotes.ts
 function containsFootnoteBlock(elements) {
   let found = false;
@@ -14127,7 +15045,9 @@ function substitute(text2) {
     result = result.replace(WHITESPACE_ONLY_LINE, "");
   }
   if (result.indexOf("\\\n") !== -1) {
-    result = result.replace(CONCAT_LINES, String.fromCharCode(57344));
+    const sentinels = makeUniqueSentinels(result);
+    const { masked, placeholders } = maskRawRegions(result, sentinels);
+    result = restorePlaceholders(masked.replace(CONCAT_LINES, String.fromCharCode(57344)), placeholders, sentinels);
   }
   if (result.indexOf("\t") !== -1) {
     result = result.replace(TABS, "    ");
@@ -14194,14 +15114,26 @@ function replaceDelimitedTypography(text2, opener, closer, leftQuote, rightQuote
   let searchFrom = 0;
   let result = "";
   let lastCopied = 0;
+  let closeIndex = -1;
+  let newlineIndex = -1;
   while (searchFrom < text2.length) {
     const openIndex = text2.indexOf(opener, searchFrom);
     if (openIndex === -1)
       break;
     const contentStart = openIndex + opener.length;
-    const closeIndex = text2.indexOf(closer, contentStart);
+    if (closeIndex < contentStart)
+      closeIndex = text2.indexOf(closer, contentStart);
     if (closeIndex === -1)
       break;
+    if (newlineIndex < contentStart) {
+      const nextNewline = text2.indexOf(`
+`, contentStart);
+      newlineIndex = nextNewline === -1 ? text2.length : nextNewline;
+    }
+    if (newlineIndex < closeIndex) {
+      searchFrom = newlineIndex + 1;
+      continue;
+    }
     result += text2.slice(lastCopied, openIndex);
     result += leftQuote;
     result += text2.slice(contentStart, closeIndex);
@@ -14212,7 +15144,12 @@ function replaceDelimitedTypography(text2, opener, closer, leftQuote, rightQuote
   return lastCopied === 0 ? text2 : result + text2.slice(lastCopied);
 }
 function substitute2(text2) {
-  let result = text2;
+  if (!text2.includes("`") && !text2.includes(",,") && !text2.includes("...") && !text2.includes(". . .")) {
+    return text2;
+  }
+  const sentinels = makeUniqueSentinels(text2);
+  const { masked, placeholders } = maskRawRegions(text2, sentinels);
+  let result = masked;
   if (result.includes("``") && result.includes("''")) {
     result = replaceDelimitedTypography(result, "``", "''", LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE);
   }
@@ -14228,7 +15165,7 @@ function substitute2(text2) {
   if (result.includes(". . .")) {
     result = replaceExactEllipsisPattern(result, ". . .");
   }
-  return result;
+  return restorePlaceholders(result, placeholders, sentinels);
 }
 
 // packages/parser/src/parser/preprocess/index.ts