@wdprlib/parser 5.1.6 → 5.2.0

package/dist/index.cjs

@@ -71,6 +71,7 @@ __export(exports_src, {
   container: () => import_ast9.container,
   compileTemplate: () => compileTemplate,
   compileListUsersTemplate: () => compileListUsersTemplate,
+  buildInfo: () => buildInfo,
   bold: () => import_ast9.bold,
   STYLE_SLOT_PREFIX: () => import_ast4.STYLE_SLOT_PREFIX,
   Parser: () => Parser,
@@ -78,6 +79,15 @@ __export(exports_src, {
   DEFAULT_SETTINGS: () => import_ast10.DEFAULT_SETTINGS
 });
 module.exports = __toCommonJS(exports_src);
+
+// packages/parser/src/build-info.generated.ts
+var buildInfo = Object.freeze({
+  version: "5.2.0",
+  sha: "cc290b0d882de3ed9ea33ec060ddfc8a7b9da59a",
+  dirty: false
+});
+
+// packages/parser/src/index.ts
 var import_ast9 = require("@wdprlib/ast");
 var import_ast10 = require("@wdprlib/ast");
 
@@ -85,49 +95,6 @@ var import_ast10 = require("@wdprlib/ast");
 function createToken(type, value, position, lineStart = false) {
   return { type, value, position, lineStart };
 }
-// packages/parser/src/lexer/token-factory.ts
-var ZERO_POSITION = {
-  start: { line: 0, column: 0, offset: 0 },
-  end: { line: 0, column: 0, offset: 0 }
-};
-function createLexerToken(state, type, value, trackPositions) {
-  return {
-    type,
-    value,
-    position: trackPositions ? currentTokenPosition(state, value) : ZERO_POSITION,
-    lineStart: isTokenAtLineStart(state)
-  };
-}
-function updateLastNonWhitespaceType(current, type) {
-  return type === "WHITESPACE" ? current : type;
-}
-function nextBlockOpenerDepth(current, type) {
-  if (type === "BLOCK_OPEN" || type === "BLOCK_END_OPEN") {
-    return current + 1;
-  }
-  if (type === "BLOCK_CLOSE" && current > 0) {
-    return current - 1;
-  }
-  return current;
-}
-function currentTokenPosition(state, value) {
-  return {
-    start: {
-      line: state.line,
-      column: state.column - value.length,
-      offset: state.pos - value.length
-    },
-    end: {
-      line: state.line,
-      column: state.column,
-      offset: state.pos
-    }
-  };
-}
-function isTokenAtLineStart(state) {
-  return state.tokens.length === 0 || state.tokens[state.tokens.length - 1]?.type === "NEWLINE";
-}
-
 // packages/parser/src/lexer/state.ts
 function createInitialLexerState(source) {
   return {
@@ -136,9 +103,16 @@ function createInitialLexerState(source) {
     line: 1,
     column: 1,
     lineStart: true,
+    quoteContentStart: false,
     tokens: []
   };
 }
+function isSyntaxLineStart(state) {
+  return state.lineStart || state.quoteContentStart;
+}
+function isLineStartQuoteMarker(token) {
+  return token?.type === "BLOCKQUOTE_MARKER" && token.lineStart;
+}
 function isAtEnd(state) {
   return state.pos >= state.source.length;
 }
@@ -152,18 +126,25 @@ function advance(state, n = 1) {
   updatePosition(state, start, end);
   return value;
 }
-function advanceByToken(state, type, length) {
+function advanceByToken(state, type, length, value = "") {
+  const afterQuoteMarker = isLineStartQuoteMarker(state.tokens[state.tokens.length - 1]);
   state.pos += length;
   if (type === "NEWLINE") {
     state.line++;
     state.column = 1;
     state.lineStart = true;
+    state.quoteContentStart = false;
     return;
   }
   state.column += length;
-  if (type !== "WHITESPACE") {
-    state.lineStart = false;
+  if (type === "WHITESPACE") {
+    if (afterQuoteMarker && value === " ") {
+      state.quoteContentStart = true;
+    }
+    return;
   }
+  state.lineStart = false;
+  state.quoteContentStart = false;
 }
 function updatePosition(state, start, end) {
   state.pos = end;
@@ -174,8 +155,9 @@ function updatePositionFromValue(state, value) {
 `);
   if (firstNewline === -1) {
     state.column += value.length;
-    if (state.lineStart && hasNonLineStartSpacing(value, 0)) {
+    if (hasNonLineStartSpacing(value, 0)) {
       state.lineStart = false;
+      state.quoteContentStart = false;
     }
     return;
   }
@@ -194,6 +176,7 @@ function updatePositionFromValue(state, value) {
   state.line += newlineCount;
   state.column = value.length - lastNewline;
   state.lineStart = !hasNonLineStartSpacing(value, lastNewline + 1);
+  state.quoteContentStart = false;
 }
 function hasNonLineStartSpacing(value, start) {
   for (let i = start;i < value.length; i++) {
@@ -205,6 +188,56 @@ function hasNonLineStartSpacing(value, start) {
   return false;
 }
 
+// packages/parser/src/lexer/token-factory.ts
+var ZERO_POSITION = {
+  start: { line: 0, column: 0, offset: 0 },
+  end: { line: 0, column: 0, offset: 0 }
+};
+function createLexerToken(state, type, value, trackPositions) {
+  return {
+    type,
+    value,
+    position: trackPositions ? currentTokenPosition(state, value) : ZERO_POSITION,
+    lineStart: isTokenAtLineStart(state)
+  };
+}
+function updateLastNonWhitespaceType(current2, type) {
+  return type === "WHITESPACE" ? current2 : type;
+}
+function nextBlockOpenerDepth(current2, type) {
+  if (type === "BLOCK_OPEN" || type === "BLOCK_END_OPEN") {
+    return current2 + 1;
+  }
+  if (type === "BLOCK_CLOSE" && current2 > 0) {
+    return current2 - 1;
+  }
+  return current2;
+}
+function currentTokenPosition(state, value) {
+  return {
+    start: {
+      line: state.line,
+      column: state.column - value.length,
+      offset: state.pos - value.length
+    },
+    end: {
+      line: state.line,
+      column: state.column,
+      offset: state.pos
+    }
+  };
+}
+function isTokenAtLineStart(state) {
+  if (state.tokens.length === 0) {
+    return true;
+  }
+  const last = state.tokens[state.tokens.length - 1];
+  if (last?.type === "NEWLINE") {
+    return true;
+  }
+  return last?.type === "WHITESPACE" && last.value === " " && isLineStartQuoteMarker(state.tokens[state.tokens.length - 2]);
+}
+
 // packages/parser/src/lexer/anchor.ts
 function findInvalidAnchorNameEnd(src, pos) {
   if (src[pos] !== "[" || src[pos + 1] !== "[" || src[pos + 2] !== "#") {
@@ -521,7 +554,7 @@ function scanPunctuationToken(input) {
     case "@":
       return { handled: true, actions: scanAtToken(source, pos) };
     case ">":
-      return { handled: true, actions: scanGreaterToken(source, pos, lineStart) };
+      return { handled: true, actions: scanGreaterToken(source, pos, input.physicalLineStart) };
     case "-":
       return { handled: true, actions: scanDashToken(source, pos, lineStart) };
     case "~": {
@@ -563,6 +596,15 @@ function runToken3(src, pos, end, type) {
 }
 
 // packages/parser/src/lexer/spacing-actions.ts
+function limitBlockquotePrefixSpace(action, previous) {
+  if (!isLineStartQuoteMarker(previous) || action.type !== "WHITESPACE") {
+    return action;
+  }
+  if (action.length <= 1 || !action.value.startsWith(" ")) {
+    return action;
+  }
+  return { type: "WHITESPACE", value: " ", length: 1 };
+}
 function scanSpacingToken(src, pos) {
   const char = src[pos];
   if (char === `
@@ -624,7 +666,7 @@ class Lexer {
     this.blockOpenerDepth = nextBlockOpenerDepth(this.blockOpenerDepth, type);
   }
   emitTokenAction(action) {
-    advanceByToken(this.state, action.type, action.length);
+    advanceByToken(this.state, action.type, action.length, action.value);
     this.addToken(action.type, action.value);
   }
   emitTokenActions(actions) {
@@ -638,11 +680,11 @@ class Lexer {
   }
   scanToken() {
     const char = this.current();
-    const isLineStart = this.state.lineStart;
+    const isLineStart = isSyntaxLineStart(this.state);
     const src = this.state.source;
     const spacingAction = scanSpacingToken(src, this.state.pos);
     if (spacingAction) {
-      this.emitTokenAction(spacingAction);
+      this.emitTokenAction(limitBlockquotePrefixSpace(spacingAction, this.state.tokens.at(-1)));
       return;
     }
     const punctuation = scanPunctuationToken({
@@ -650,6 +692,7 @@ class Lexer {
       source: src,
       pos: this.state.pos,
       lineStart: isLineStart,
+      physicalLineStart: this.state.lineStart,
       splitBlockClose: this.splitBlockClosePositions.has(this.state.pos),
       findInvalidAnchorNameEnd: () => this.findInvalidAnchorNameEnd()
     });
@@ -866,7 +909,7 @@ function parseBlocksUntil(ctx, closeCondition, options) {
   const elements = [];
   let consumed = 0;
   let pos = ctx.pos;
-  const excluded = options?.excludedBlockNames;
+  const excluded = mergeExcludedBlockNames(ctx.scope.excludedBlockNames, options?.excludedBlockNames);
   const blockRules = excluded ? getExcludedBlockRules(ctx.blockRules, excluded) : ctx.blockRules;
   const blockScope = {
     ...ctx.scope,
@@ -908,6 +951,13 @@ function parseBlocksUntil(ctx, closeCondition, options) {
   }
   return { elements, consumed };
 }
+function mergeExcludedBlockNames(inherited, added) {
+  if (!inherited?.size)
+    return added;
+  if (!added?.size)
+    return inherited;
+  return new Set([...inherited, ...added]);
+}
 function getExcludedBlockRules(blockRules, excluded) {
   let byExcluded = excludedBlockRulesCache.get(blockRules);
   if (!byExcluded) {
@@ -944,6 +994,31 @@ function getCandidateInlineRules(inlineRules, tokenType) {
   byType.set(tokenType, candidates);
   return candidates;
 }
+// packages/parser/src/parser/rules/inline/raw/end.ts
+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;
+  for (let pos = start + 1;pos < end; pos++) {
+    if (tokens[pos]?.type === "NEWLINE" || tokens[pos]?.type === "EOF")
+      break;
+    if (tokens[pos]?.type === close)
+      return pos + 1;
+  }
+  return start;
+}
+function protectedInlineRegionEnd(tokens, start, end) {
+  const rawEnd = rawRegionEnd(tokens, start, end);
+  if (rawEnd > start || tokens[start]?.type !== "COMMENT_OPEN")
+    return rawEnd;
+  for (let pos = start + 1;pos < end; pos++) {
+    if (tokens[pos]?.type === "COMMENT_CLOSE")
+      return pos + 1;
+  }
+  return start;
+}
+
 // packages/parser/src/parser/rules/inline/parsing/plain-text.ts
 var MIN_INLINE_TEXT_RUN_LENGTH = 32;
 var MIN_INLINE_TEXT_RUN_DOCUMENT_TOKENS = 1e5;
@@ -986,6 +1061,135 @@ function isPlainTextRunToken(ctx, pos) {
   return token5.value !== "(";
 }
 
+// packages/parser/src/parser/rules/inline/image/attributes.ts
+function parseImageAttributes(ctx, startPos) {
+  const result = parseAttributesRaw(ctx, startPos, false);
+  const link = result.attrs.link ?? null;
+  const { link: _link, ...htmlAttributes } = result.attrs;
+  return {
+    attributes: filterUnsafeAttributes(htmlAttributes),
+    link,
+    consumed: result.consumed
+  };
+}
+
+// packages/parser/src/parser/rules/inline/image/body.ts
+function parseImageSourceText(ctx, startPos) {
+  let pos = startPos;
+  let consumed = 0;
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+  let sourceText = "";
+  while (pos < ctx.tokens.length) {
+    const token5 = ctx.tokens[pos];
+    if (!token5 || token5.type === "WHITESPACE" || token5.type === "BLOCK_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF") {
+      break;
+    }
+    sourceText += token5.value;
+    pos++;
+    consumed++;
+  }
+  return { sourceText, consumed };
+}
+
+// packages/parser/src/parser/rules/inline/image/syntax.ts
+var IMAGE_BLOCK_NAMES = new Set([
+  "image",
+  "=image",
+  "<image",
+  ">image",
+  "f<image",
+  "f>image",
+  "f=image"
+]);
+function parseImageBlockName(ctx, startPos) {
+  let pos = startPos;
+  let consumed = 0;
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+  const prefixResult = parseImagePrefix(ctx, pos);
+  const prefix = prefixResult.prefix;
+  pos += prefixResult.consumed;
+  consumed += prefixResult.consumed;
+  const nameToken = ctx.tokens[pos];
+  if (!nameToken || nameToken.type !== "TEXT" && nameToken.type !== "IDENTIFIER") {
+    return null;
+  }
+  return { name: prefix + nameToken.value.toLowerCase(), consumed: consumed + 1 };
+}
+function isImageBlockName(blockName) {
+  return IMAGE_BLOCK_NAMES.has(blockName);
+}
+function parseImagePrefix(ctx, pos) {
+  const token5 = ctx.tokens[pos];
+  if (token5?.type === "EQUALS") {
+    return { prefix: "=", consumed: 1 };
+  }
+  if (token5?.type === "TEXT" && token5.value === "<") {
+    return { prefix: "<", consumed: 1 };
+  }
+  if ((token5?.type === "TEXT" || token5?.type === "BLOCKQUOTE_MARKER") && token5.value === ">") {
+    return { prefix: ">", consumed: 1 };
+  }
+  if (token5?.type === "IDENTIFIER" && token5.value.toLowerCase() === "f") {
+    return parseFloatPrefix(ctx, pos + 1);
+  }
+  return { prefix: "", consumed: 0 };
+}
+function parseFloatPrefix(ctx, pos) {
+  const token5 = ctx.tokens[pos];
+  if (token5?.type === "TEXT" && token5.value === "<") {
+    return { prefix: "f<", consumed: 2 };
+  }
+  if ((token5?.type === "TEXT" || token5?.type === "BLOCKQUOTE_MARKER") && token5.value === ">") {
+    return { prefix: "f>", consumed: 2 };
+  }
+  if (token5?.type === "EQUALS") {
+    return { prefix: "f=", consumed: 2 };
+  }
+  return { prefix: "", consumed: 0 };
+}
+
+// packages/parser/src/parser/rules/inline/image/open.ts
+function parseImageOpen(ctx) {
+  if (ctx.tokens[ctx.pos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+  const nameResult = parseImageBlockName(ctx, pos);
+  if (!nameResult || !isImageBlockName(nameResult.name)) {
+    return null;
+  }
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+  const sourceText = parseImageSourceText(ctx, pos);
+  pos += sourceText.consumed;
+  consumed += sourceText.consumed;
+  const attrs = parseImageAttributes(ctx, pos);
+  pos += attrs.consumed;
+  consumed += attrs.consumed;
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+  if (!sourceText.sourceText) {
+    return null;
+  }
+  return {
+    blockName: nameResult.name,
+    sourceText: sourceText.sourceText,
+    link: attrs.link,
+    attributes: attrs.attributes,
+    consumed
+  };
+}
+
 // packages/parser/src/parser/constants.ts
 var BLOCK_START_TOKENS = [
   "BLOCKQUOTE_MARKER",
@@ -1116,7 +1320,7 @@ function isParagraphBreakingBlockStart(ctx, newlinePos, lookAhead) {
   if (!nextMeaningfulToken.lineStart && !isIndentedBlockOpener) {
     return false;
   }
-  return !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) && !isExcludedBlockStart(ctx, nextPos) && !isUnknownBlockStart(ctx, nextPos);
 }
 function isOrphanCloseSpan(ctx, blockEndOpenPos) {
   const token5 = ctx.tokens[blockEndOpenPos];
@@ -1226,27 +1430,45 @@ function parseInlineUntil(ctx, endType) {
   let consumed = 0;
   let pos = ctx.pos;
   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);
+      if (protectedEnd > end) {
+        end = protectedEnd - 1;
+        continue;
+      }
+      if (ctx.tokens[end]?.type === "NEWLINE" && ctx.tokens[end - 1]?.type === "UNDERSCORE" && ctx.tokens[end - 2]?.type === "WHITESPACE")
+        continue;
+      if (ctx.tokens[end]?.type === "NEWLINE" || ctx.tokens[end]?.type === endType) {
+        inlineEnd = end;
+        break;
+      }
+    }
+  }
   const { inlineRules } = ctx;
   const inlineCtx = {
     ...ctx,
-    pos
+    pos,
+    scope: { ...ctx.scope, inlineEnd }
   };
   const canCollectLongPlainTextRuns = ctx.tokens.length >= MIN_INLINE_TEXT_RUN_DOCUMENT_TOKENS;
-  while (pos < ctx.tokens.length) {
+  while (pos < inlineEnd) {
     const token5 = ctx.tokens[pos];
     if (!token5 || token5.type === "EOF") {
       break;
     }
-    if (paragraphMode && ctx.scope.blockCloseCondition) {
+    if (ctx.scope.blockCloseCondition) {
       const checkCtx = { ...ctx, pos };
       if (ctx.scope.blockCloseCondition(checkCtx)) {
         break;
       }
     }
-    if (!paragraphMode && token5.type === "NEWLINE") {
+    if (!multiline && token5.type === "NEWLINE") {
       break;
     }
-    if (paragraphMode && token5.type === "NEWLINE") {
+    if (multiline && token5.type === "NEWLINE" && !ctx.scope.tableFormatting) {
       const boundary = getParagraphNewlineBoundary(ctx, pos, nodes.length > 0);
       if (boundary.shouldBreak) {
         if (boundary.preservePrecedingLineBreak) {
@@ -1256,6 +1478,11 @@ function parseInlineUntil(ctx, endType) {
         break;
       }
     }
+    if (ctx.scope.tableFormatting?.suppressedClosers.has(pos)) {
+      pos++;
+      consumed++;
+      continue;
+    }
     if (token5.type === endType) {
       break;
     }
@@ -1280,6 +1507,24 @@ function parseInlineUntil(ctx, endType) {
     for (const rule of getCandidateInlineRules(inlineRules, token5.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
+        if (rule.name === "comment") {
+          let after = pos + result.consumed;
+          while (ctx.tokens[after]?.type === "WHITESPACE")
+            after++;
+          if (ctx.tokens[after]?.type === "NEWLINE" || ctx.tokens[after]?.type === "EOF") {
+            while (nodes.at(-1)?.element === "text") {
+              const last = nodes.at(-1);
+              if (last.element !== "text")
+                break;
+              last.data = last.data.trimEnd();
+              if (last.data)
+                break;
+              nodes.pop();
+            }
+            if (nodes.at(-1)?.element === "line-break")
+              nodes.pop();
+          }
+        }
         nodes.push(...result.elements);
         consumed += result.consumed;
         pos += result.consumed;
@@ -1295,6 +1540,16 @@ function parseInlineUntil(ctx, endType) {
   }
   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])) {
@@ -1470,7 +1725,7 @@ function eofToken() {
 }
 function hasClosingMarkerBeforeNewline(ctx, markerType, markerValue) {
   let pos = ctx.pos;
-  while (pos < ctx.tokens.length) {
+  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
     const token5 = ctx.tokens[pos];
     if (!token5 || token5.type === "NEWLINE" || token5.type === "EOF") {
       return false;
@@ -1484,31 +1739,6 @@ function hasClosingMarkerBeforeNewline(ctx, markerType, markerValue) {
   }
   return false;
 }
-function hasClosingMarkerBeforeParagraphBreak(ctx, markerType, markerValue) {
-  let pos = ctx.pos;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "EOF") {
-      return false;
-    }
-    if (token5.type === "NEWLINE") {
-      let lookAhead = 1;
-      while (ctx.tokens[pos + lookAhead]?.type === "WHITESPACE") {
-        lookAhead++;
-      }
-      if (ctx.tokens[pos + lookAhead]?.type === "NEWLINE" || ctx.tokens[pos + lookAhead]?.type === "EOF" || !ctx.tokens[pos + lookAhead]) {
-        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];
@@ -1575,6 +1805,15 @@ var headingRule = {
     const inlineCtx = { ...ctx, pos };
     const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
     const children = inlineResult.elements;
+    while (children.at(-1)?.element === "text") {
+      const last = children.at(-1);
+      if (last.element !== "text")
+        break;
+      last.data = last.data.trimEnd();
+      if (last.data)
+        break;
+      children.pop();
+    }
     consumed += inlineResult.consumed;
     pos += inlineResult.consumed;
     if (ctx.tokens[pos]?.type === "NEWLINE") {
@@ -2374,17 +2613,15 @@ function parseBlockquoteLine(ctx, startPos) {
   if (ctx.tokens[pos]?.type !== "WHITESPACE") {
     return { kind: "skipped", consumed: consumeLineRemainder(ctx, pos) + consumed };
   }
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+  pos++;
+  consumed++;
+  const contentStart = pos;
+  while (pos < ctx.tokens.length && ctx.tokens[pos]?.type !== "NEWLINE" && ctx.tokens[pos]?.type !== "EOF") {
     pos++;
     consumed++;
   }
-  const inlineCtx = { ...ctx, pos };
-  const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
-  consumed += inlineResult.consumed;
-  pos += inlineResult.consumed;
-  let hasLineBreak = false;
   if (ctx.tokens[pos]?.type === "NEWLINE") {
-    hasLineBreak = true;
+    pos++;
     consumed++;
   }
   return {
@@ -2392,7 +2629,7 @@ function parseBlockquoteLine(ctx, startPos) {
     line: {
       depth: depth - 1,
       ltype: null,
-      value: { elements: inlineResult.elements, hasLineBreak }
+      value: { start: contentStart, end: pos }
     },
     consumed
   };
@@ -2411,47 +2648,43 @@ function consumeLineRemainder(ctx, startPos) {
 }
 
 // packages/parser/src/parser/rules/block/blockquote/build.ts
-function buildBlockquoteElements(lines) {
+var EXCLUDED_BLOCK_NAMES = new Set([
+  "bibliography",
+  "code",
+  "html",
+  "include",
+  "math",
+  "module"
+]);
+var NEVER_CLOSES = () => false;
+function buildBlockquoteElements(ctx, lines) {
   const depthTrees = processDepths(null, lines);
-  return depthTrees.map(({ list }) => buildBlockquoteElement(list));
+  return depthTrees.map(({ list }) => buildBlockquoteElement(ctx, list)).filter((element) => element !== null);
 }
-function buildBlockquoteElement(list) {
+function buildBlockquoteElement(ctx, list) {
   const children = [];
-  let currentParagraphChildren = [];
-  function flushParagraph() {
-    if (currentParagraphChildren.length > 0) {
-      while (currentParagraphChildren.length > 0 && currentParagraphChildren[currentParagraphChildren.length - 1]?.element === "line-break") {
-        currentParagraphChildren.pop();
-      }
-      if (currentParagraphChildren.length > 0) {
-        children.push({
-          element: "container",
-          data: {
-            type: "paragraph",
-            attributes: {},
-            elements: currentParagraphChildren
-          }
-        });
-      }
-      currentParagraphChildren = [];
-    }
+  let pending = [];
+  function flushPending() {
+    if (pending.length === 0)
+      return;
+    children.push(...parseLines(ctx, pending));
+    pending = [];
   }
   for (const item of list) {
     if (item.kind === "item") {
-      if (item.value.elements.length === 0) {
-        flushParagraph();
-        continue;
-      }
-      currentParagraphChildren.push(...item.value.elements);
-      if (item.value.hasLineBreak) {
-        currentParagraphChildren.push({ element: "line-break" });
-      }
-    } else {
-      flushParagraph();
-      children.push(buildBlockquoteElement(item.children));
+      pending.push(item.value);
+      continue;
     }
+    flushPending();
+    const nested = buildBlockquoteElement(ctx, item.children);
+    if (nested) {
+      children.push(nested);
+    }
+  }
+  flushPending();
+  if (children.length === 0) {
+    return null;
   }
-  flushParagraph();
   return {
     element: "container",
     data: {
@@ -2461,6 +2694,31 @@ function buildBlockquoteElement(list) {
     }
   };
 }
+function parseLines(ctx, lines) {
+  const tokens = sliceLineTokens(ctx, lines);
+  const lineCtx = { ...ctx, tokens, pos: 0 };
+  return parseBlocksUntil(lineCtx, NEVER_CLOSES, {
+    excludedBlockNames: EXCLUDED_BLOCK_NAMES
+  }).elements;
+}
+function sliceLineTokens(ctx, lines) {
+  const tokens = [];
+  for (const { start, end } of lines) {
+    for (let pos = start;pos < end; pos++) {
+      const token5 = ctx.tokens[pos];
+      if (token5) {
+        tokens.push(token5);
+      }
+    }
+  }
+  const last = tokens[tokens.length - 1];
+  tokens.push(createToken("EOF", "", last?.position ?? ZERO_POSITION2));
+  return tokens;
+}
+var ZERO_POSITION2 = {
+  start: { line: 0, column: 0, offset: 0 },
+  end: { line: 0, column: 0, offset: 0 }
+};
 
 // packages/parser/src/parser/rules/block/blockquote/lines.ts
 function collectBlockquoteLines(ctx) {
@@ -2469,16 +2727,90 @@ function collectBlockquoteLines(ctx) {
   let consumed = 0;
   while (pos < ctx.tokens.length) {
     const result = parseBlockquoteLine(ctx, pos);
-    if (result.kind === "stop")
-      break;
+    if (result.kind === "stop") {
+      const resumed = extendToCommentClose(ctx, lines, pos);
+      if (resumed === pos)
+        break;
+      consumed += resumed - pos;
+      pos = resumed;
+      continue;
+    }
     pos += result.consumed;
     consumed += result.consumed;
     if (result.kind === "parsed") {
       lines.push(result.line);
     }
   }
+  blankCommentOnlyLines(ctx, lines);
   return { lines, consumed };
 }
+function extendToCommentClose(ctx, lines, stopPos) {
+  const last = lines[lines.length - 1];
+  if (!last || !endsInsideComment(ctx, lines)) {
+    return stopPos;
+  }
+  let pos = stopPos;
+  while (pos < ctx.tokens.length && ctx.tokens[pos]?.type !== "COMMENT_CLOSE") {
+    if (ctx.tokens[pos]?.type === "EOF")
+      return stopPos;
+    pos++;
+  }
+  while (pos < ctx.tokens.length && ctx.tokens[pos]?.type !== "EOF") {
+    pos++;
+    if (ctx.tokens[pos - 1]?.type === "NEWLINE")
+      break;
+  }
+  last.value.end = pos;
+  return pos;
+}
+function endsInsideComment(ctx, lines) {
+  let open = false;
+  for (const { value } of lines) {
+    for (let pos = value.start;pos < value.end; pos++) {
+      const type = ctx.tokens[pos]?.type;
+      if (type === "COMMENT_OPEN")
+        open = true;
+      else if (type === "COMMENT_CLOSE")
+        open = false;
+    }
+  }
+  return open;
+}
+function blankCommentOnlyLines(ctx, lines) {
+  const positions = [];
+  lines.forEach((line, index) => {
+    for (let pos = line.value.start;pos < line.value.end; pos++) {
+      if (ctx.tokens[pos]?.type !== "NEWLINE") {
+        positions.push({ line: index, pos });
+      }
+    }
+  });
+  const commented = Array.from({ length: positions.length }, () => false);
+  for (let open = 0;open < positions.length; open++) {
+    if (ctx.tokens[positions[open].pos]?.type !== "COMMENT_OPEN")
+      continue;
+    let close = open + 1;
+    while (close < positions.length && ctx.tokens[positions[close].pos]?.type !== "COMMENT_CLOSE") {
+      close++;
+    }
+    if (close === positions.length)
+      break;
+    commented.fill(true, open, close + 1);
+    open = close;
+  }
+  const hasContent = Array.from({ length: lines.length }, () => false);
+  positions.forEach(({ line, pos }, index) => {
+    if (commented[index] || ctx.tokens[pos]?.type === "WHITESPACE")
+      return;
+    hasContent[line] = true;
+  });
+  lines.forEach((line, index) => {
+    if (hasContent[index])
+      return;
+    const { end } = line.value;
+    line.value.start = ctx.tokens[end - 1]?.type === "NEWLINE" ? end - 1 : end;
+  });
+}
 
 // packages/parser/src/parser/rules/block/blockquote/index.ts
 var blockquoteRule = {
@@ -2497,9 +2829,9 @@ var blockquoteRule = {
       }
       return { success: false };
     }
-    const blockquotes = buildBlockquoteElements(blockquoteLines.lines);
+    const blockquotes = buildBlockquoteElements(ctx, blockquoteLines.lines);
     if (blockquotes.length === 0) {
-      return { success: false };
+      return { success: true, elements: [], consumed: blockquoteLines.consumed };
     }
     return {
       success: true,
@@ -2594,17 +2926,8 @@ function parseDefinitionItemValue(ctx, startPos) {
       break;
     }
     if (token5.type === "NEWLINE") {
-      const nextToken = ctx.tokens[pos + 1];
-      if (nextToken?.type === "COLON" && nextToken.lineStart) {
-        pos++;
-        consumed++;
-        break;
-      }
-      if (nextToken?.type === "NEWLINE" || !nextToken || nextToken.type === "EOF") {
-        pos++;
-        consumed++;
-        break;
-      }
+      consumed++;
+      break;
     }
     const inlineCtx = { ...ctx, pos };
     const result = parseInlineUntil(inlineCtx, "NEWLINE");
@@ -2682,14 +3005,10 @@ var definitionListRule = {
     if (result.items.length === 0) {
       return { success: false };
     }
+    const items = toDefinitionListItems(result.items.filter((item) => item.value.length > 0));
     return {
       success: true,
-      elements: [
-        {
-          element: "definition-list",
-          data: toDefinitionListItems(result.items)
-        }
-      ],
+      elements: items.length > 0 ? [{ element: "definition-list", data: items }] : [],
       consumed: result.consumed
     };
   }
@@ -2794,20 +3113,49 @@ var paragraphRule = {
     }
     return {
       success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "paragraph",
-            attributes: {},
-            elements
-          }
-        }
-      ],
+      elements: wrapParagraphElements(elements),
       consumed: result.consumed
     };
   }
 };
+function wrapParagraphElements(elements) {
+  const output = [];
+  let group = [];
+  let bare = false;
+  const flush = (trimBreaks = false) => {
+    const content = trimBreaks ? normalizeParagraphElements(group) : group;
+    while (content[0]?.element === "line-break")
+      content.shift();
+    while (content.length) {
+      const last = content.at(-1);
+      if (last.element !== "text" || last.data.trim() !== "")
+        break;
+      content.pop();
+    }
+    while (content[0]?.element === "text" && content[0].data.trim() === "")
+      content.shift();
+    if (content[0]?.element === "text")
+      content[0] = { element: "text", data: content[0].data.trimStart() };
+    if (content.length)
+      output.push(...bare || content.some((el) => el.element === "image") ? content : [
+        {
+          element: "container",
+          data: { type: "paragraph", attributes: {}, elements: content }
+        }
+      ]);
+    group = [];
+  };
+  for (const el of elements) {
+    if (el.element === "image" && el.data.alignment !== null || el.element === "embed-block") {
+      flush(el.element === "image");
+      output.push(el);
+      bare = el.element === "embed-block";
+    } else
+      group.push(el);
+  }
+  flush();
+  return output;
+}
 
 // packages/parser/src/parser/rules/block/div/close.ts
 function isDivClose(ctx) {
@@ -3173,9 +3521,6 @@ function consumeCodeClose(ctx, startPos, closeNameConsumed) {
     pos++;
     consumed++;
   }
-  if (ctx.tokens[pos]?.type === "NEWLINE") {
-    consumed++;
-  }
   return consumed;
 }
 
@@ -3232,16 +3577,13 @@ var codeBlockRule = {
       name: attrResult.attrs.name ?? null
     };
     ctx.codeBlocks.push(codeBlockData);
-    return {
-      success: true,
-      elements: [
-        {
-          element: "code",
-          data: codeBlockData
-        }
-      ],
-      consumed
-    };
+    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 };
   }
 };
 
@@ -3620,7 +3962,30 @@ function parseTableCell(ctx, startPos, cellStart) {
     consumed++;
   }
   const { inlineRules } = ctx;
-  const inlineCtx = { ...ctx, pos };
+  let inlineEnd = pos;
+  while (inlineEnd < ctx.tokens.length) {
+    const rawEnd = protectedInlineRegionEnd(ctx.tokens, inlineEnd, ctx.tokens.length);
+    if (rawEnd > inlineEnd) {
+      inlineEnd = rawEnd;
+      continue;
+    }
+    const token5 = ctx.tokens[inlineEnd];
+    if (!token5 || token5.type === "EOF" || token5.type === "NEWLINE" || isPipeTableToken(token5.type))
+      break;
+    if (token5.type === "WHITESPACE" && ctx.tokens[inlineEnd + 1]?.type === "UNDERSCORE" && ctx.tokens[inlineEnd + 2]?.type === "NEWLINE")
+      inlineEnd += 3;
+    else
+      inlineEnd++;
+  }
+  const inlineCtx = {
+    ...ctx,
+    pos,
+    scope: {
+      ...ctx.scope,
+      inlineEnd,
+      tableFormatting: isPipeTableToken(ctx.tokens[inlineEnd]?.type ?? "EOF") ? ctx.scope.tableFormatting : undefined
+    }
+  };
   while (pos < ctx.tokens.length) {
     const token5 = ctx.tokens[pos];
     if (!token5 || token5.type === "NEWLINE" || token5.type === "EOF") {
@@ -3629,6 +3994,11 @@ function parseTableCell(ctx, startPos, cellStart) {
     if (isPipeTableToken(token5.type)) {
       break;
     }
+    if (ctx.scope.tableFormatting?.suppressedClosers.has(pos)) {
+      pos++;
+      consumed++;
+      continue;
+    }
     if (tryConsumeUnderscoreLineBreak(ctx, pos, children)) {
       pos += 3;
       consumed += 3;
@@ -3688,6 +4058,21 @@ function tryConsumeUnderscoreLineBreak(ctx, pos, children) {
 
 // packages/parser/src/parser/rules/block/table/pipe/row.ts
 function parsePipeTableRows(ctx, startPos) {
+  let end = startPos;
+  while (end < ctx.tokens.length && ctx.tokens[end]?.type !== "EOF") {
+    const protectedEnd = protectedInlineRegionEnd(ctx.tokens, end, ctx.tokens.length);
+    if (protectedEnd > end) {
+      end = protectedEnd;
+      continue;
+    }
+    if (ctx.tokens[end]?.type === "NEWLINE" && !isPipeTableToken(ctx.tokens[end + 1]?.type ?? "EOF") && !(ctx.tokens[end - 1]?.type === "UNDERSCORE" && ctx.tokens[end - 2]?.type === "WHITESPACE"))
+      break;
+    end++;
+  }
+  const tableCtx = {
+    ...ctx,
+    scope: { ...ctx.scope, tableFormatting: { end, suppressedClosers: new Set } }
+  };
   const rows = [];
   let pos = startPos;
   let consumed = 0;
@@ -3696,7 +4081,7 @@ function parsePipeTableRows(ctx, startPos) {
     if (!token5 || !token5.lineStart || !isPipeTableToken(token5.type)) {
       break;
     }
-    const rowResult = parseTableRow(ctx, pos);
+    const rowResult = parseTableRow(tableCtx, pos);
     rows.push(rowResult.row);
     pos += rowResult.consumed;
     consumed += rowResult.consumed;
@@ -9124,6 +9509,8 @@ var embedBlockRule = {
   name: "embed-block",
   startTokens: ["BLOCK_OPEN"],
   requiresLineStart: false,
+  preservesPrecedingLineBreak: true,
+  isStartPattern: (ctx, pos) => parseEmbedBlockOpen(ctx, pos) !== null,
   parse(ctx) {
     const openToken = currentToken(ctx);
     if (openToken.type !== "BLOCK_OPEN") {
@@ -9139,38 +9526,30 @@ var embedBlockRule = {
     pos += contentResult.consumed;
     consumed += contentResult.consumed;
     if (!contentResult.foundClose) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: `Missing closing tag [[/${openResult.blockName}]] for [[${openResult.blockName}]]`,
-        position: openToken.position
-      });
+      if (!ctx.diagnostics.some((d) => d.code === "unclosed-block" && d.position === openToken.position))
+        ctx.diagnostics.push({
+          severity: "warning",
+          code: "unclosed-block",
+          message: `Missing closing tag [[/${openResult.blockName}]] for [[${openResult.blockName}]]`,
+          position: openToken.position
+        });
       return { success: false };
     }
     const closeConsumed = consumeEmbedClose(ctx, pos);
     pos += closeConsumed;
     consumed += closeConsumed;
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "paragraph",
-            attributes: {},
-            elements: [
-              {
-                element: "embed-block",
-                data: {
-                  contents: contentResult.contents.trim()
-                }
-              }
-            ]
-          }
-        }
-      ],
-      consumed
-    };
+    const elements = [
+      { element: "embed-block", data: { contents: contentResult.contents.trim() } }
+    ];
+    if (ctx.scope.inlineEnd === undefined && ctx.tokens[pos]?.type !== "NEWLINE" && ctx.tokens[pos]?.type !== "EOF") {
+      const after = parseInlineUntil({ ...ctx, pos }, "PARAGRAPH_BREAK");
+      const tail = normalizeParagraphElements(after.elements);
+      if (tail[0]?.element === "text")
+        tail[0].data = tail[0].data.trimStart();
+      elements.push(...tail);
+      consumed += after.consumed;
+    }
+    return { success: true, elements, consumed };
   }
 };
 
@@ -9484,11 +9863,11 @@ var iftagsRule = {
 };
 
 // packages/parser/src/parser/rules/block/toc/element.ts
-function createTocElement(align) {
+function createTocElement(align, title) {
   return {
     element: "table-of-contents",
     data: {
-      attributes: {},
+      attributes: title === undefined ? {} : { title },
       align
     }
   };
@@ -9531,26 +9910,17 @@ function parseTocOpen(ctx, startPos) {
   } else {
     return null;
   }
-  pos = skipUntilClose(ctx, pos);
+  const attributes = parseAttributes(ctx, pos);
+  pos += attributes.consumed;
   if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
     return null;
   }
   return {
     align,
+    title: attributes.attrs.title,
     consumed: pos + 1 - startPos
   };
 }
-function skipUntilClose(ctx, startPos) {
-  let pos = startPos;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "BLOCK_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF") {
-      break;
-    }
-    pos++;
-  }
-  return pos;
-}
 function isNameToken(token5) {
   return token5?.type === "TEXT" || token5?.type === "IDENTIFIER";
 }
@@ -9574,7 +9944,7 @@ var tocRule = {
     }
     return {
       success: true,
-      elements: [createTocElement(openResult.align)],
+      elements: [createTocElement(openResult.align, openResult.title)],
       consumed: openResult.consumed
     };
   }
@@ -10175,6 +10545,31 @@ var blockRules = [
   galleryRule,
   divRule
 ];
+// packages/parser/src/parser/rules/inline/formatting/close.ts
+function findFormattingClose(ctx, start, marker) {
+  const table = ctx.scope.tableFormatting;
+  const end = table?.end ?? ctx.scope.inlineEnd ?? ctx.tokens.length;
+  for (let pos = start;pos < end; pos++) {
+    const token5 = ctx.tokens[pos];
+    if (!token5 || token5.type === "EOF" || ctx.scope.blockCloseCondition?.({ ...ctx, pos }))
+      return null;
+    if (!table && token5.type === "NEWLINE" && getParagraphNewlineBoundary(ctx, pos, true).shouldBreak)
+      return null;
+    if (token5.type === marker && !table?.suppressedClosers.has(pos))
+      return pos;
+    const protectedEnd = protectedInlineRegionEnd(ctx.tokens, pos, end);
+    if (protectedEnd > pos)
+      pos = protectedEnd - 1;
+  }
+  return null;
+}
+function consumeFormattingClose(ctx, close, contentEnd) {
+  if (close === contentEnd)
+    return 1;
+  ctx.scope.tableFormatting?.suppressedClosers.add(close);
+  return 0;
+}
+
 // packages/parser/src/parser/rules/inline/formatting/container.ts
 function createInlineContainer(type, elements) {
   return {
@@ -10186,9 +10581,10 @@ function createInlineContainer(type, elements) {
     }
   };
 }
-function parseSameLineDelimitedContainer(ctx, closeToken, type, options = {}) {
+function parseDelimitedContainer(ctx, closeToken, type, options = {}) {
   const startToken = currentToken(ctx);
-  if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, closeToken)) {
+  const close = findFormattingClose(ctx, ctx.pos + 1, closeToken);
+  if (close === null) {
     return {
       success: true,
       elements: [{ element: "text", data: startToken.value }],
@@ -10196,7 +10592,7 @@ function parseSameLineDelimitedContainer(ctx, closeToken, type, options = {}) {
     };
   }
   const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, closeToken);
-  const consumed = 1 + result.consumed + 1;
+  const consumed = 1 + result.consumed + consumeFormattingClose(ctx, close, ctx.pos + 1 + result.consumed);
   if (options.discardEmpty === true && result.elements.length === 0) {
     return {
       success: true,
@@ -10216,7 +10612,7 @@ var boldRule = {
   name: "bold",
   startTokens: ["BOLD_MARKER"],
   parse(ctx) {
-    return parseSameLineDelimitedContainer(ctx, "BOLD_MARKER", "bold", { discardEmpty: true });
+    return parseDelimitedContainer(ctx, "BOLD_MARKER", "bold", { discardEmpty: true });
   }
 };
 
@@ -10225,102 +10621,28 @@ var italicRule = {
   name: "italic",
   startTokens: ["ITALIC_MARKER"],
   parse(ctx) {
-    return parseSameLineDelimitedContainer(ctx, "ITALIC_MARKER", "italics");
+    return parseDelimitedContainer(ctx, "ITALIC_MARKER", "italics");
   }
 };
 
-// packages/parser/src/parser/rules/inline/underline/child.ts
-function parseUnderlineChild(ctx, pos) {
-  const token5 = ctx.tokens[pos];
-  if (!token5) {
-    return { elements: [], consumed: 0 };
-  }
-  if (token5.type === "NEWLINE") {
-    return { elements: [{ element: "line-break" }], consumed: 1 };
-  }
-  const result = parseInlineUntil({ ...ctx, pos }, "UNDERLINE_MARKER");
-  if (result.elements.length > 0) {
-    return { elements: result.elements, consumed: result.consumed };
-  }
-  return { elements: [{ element: "text", data: token5.value }], consumed: 1 };
-}
-
-// packages/parser/src/parser/rules/inline/underline/content.ts
-function parseUnderlineContent(ctx, startPos) {
-  const children = [];
-  let pos = startPos;
-  let consumed = 1;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "EOF")
-      break;
-    if (token5.type === "UNDERLINE_MARKER") {
-      consumed++;
-      break;
-    }
-    const child = parseUnderlineChild(ctx, pos);
-    children.push(...child.elements);
-    pos += child.consumed;
-    consumed += child.consumed;
-  }
-  return { children, consumed };
-}
-
 // packages/parser/src/parser/rules/inline/underline/index.ts
 var underlineRule = {
   name: "underline",
   startTokens: ["UNDERLINE_MARKER"],
   parse(ctx) {
-    const startToken = currentToken(ctx);
-    if (!hasClosingMarkerBeforeParagraphBreak({ ...ctx, pos: ctx.pos + 1 }, "UNDERLINE_MARKER")) {
-      return {
-        success: true,
-        elements: [{ element: "text", data: startToken.value }],
-        consumed: 1
-      };
-    }
-    const { children, consumed } = parseUnderlineContent(ctx, ctx.pos + 1);
-    if (children.length === 0) {
-      return {
-        success: true,
-        elements: [],
-        consumed
-      };
-    }
-    return {
-      success: true,
-      elements: [createInlineContainer("underline", children)],
-      consumed
-    };
+    return parseDelimitedContainer(ctx, "UNDERLINE_MARKER", "underline", { discardEmpty: true });
   }
 };
 
 // packages/parser/src/parser/rules/inline/strikethrough/parse.ts
 function parseStrikethroughContent(ctx) {
-  const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "STRIKE_MARKER");
-  return {
-    success: true,
-    elements: [createInlineContainer("strikethrough", result.elements)],
-    consumed: 1 + result.consumed + 1
-  };
+  return parseDelimitedContainer(ctx, "STRIKE_MARKER", "strikethrough");
 }
 
 // packages/parser/src/parser/rules/inline/strikethrough/syntax.ts
 function hasValidStrikethroughClose(ctx) {
-  let pos = ctx.pos + 1;
-  let prevWasWhitespace = false;
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "NEWLINE" || token5.type === "EOF") {
-      return false;
-    }
-    if (token5.type === "STRIKE_MARKER") {
-      return !prevWasWhitespace;
-    }
-    prevWasWhitespace = token5.type === "WHITESPACE";
-    pos++;
-  }
-  return false;
+  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
@@ -10344,7 +10666,7 @@ var superscriptRule = {
   name: "superscript",
   startTokens: ["SUPER_MARKER"],
   parse(ctx) {
-    return parseSameLineDelimitedContainer(ctx, "SUPER_MARKER", "superscript", {
+    return parseDelimitedContainer(ctx, "SUPER_MARKER", "superscript", {
       discardEmpty: true
     });
   }
@@ -10355,7 +10677,7 @@ var subscriptRule = {
   name: "subscript",
   startTokens: ["SUB_MARKER"],
   parse(ctx) {
-    return parseSameLineDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
+    return parseDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
   }
 };
 
@@ -10364,7 +10686,7 @@ var monospaceRule = {
   name: "monospace",
   startTokens: ["MONO_MARKER"],
   parse(ctx) {
-    return parseSameLineDelimitedContainer(ctx, "MONO_CLOSE", "monospace");
+    return parseDelimitedContainer(ctx, "MONO_CLOSE", "monospace");
   }
 };
 
@@ -10725,13 +11047,14 @@ var linkStarRule = {
 
 // packages/parser/src/parser/rules/inline/color/syntax.ts
 function parseColorContent(ctx) {
-  if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "COLOR_MARKER")) {
+  const close = findFormattingClose(ctx, ctx.pos + 1, "COLOR_MARKER");
+  if (close === null) {
     return null;
   }
   let pos = ctx.pos + 1;
   let consumed = 1;
   let colorSpec = "";
-  while (pos < ctx.tokens.length) {
+  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
     const token5 = ctx.tokens[pos];
     if (!token5 || token5.type === "PIPE" || token5.type === "COLOR_MARKER" || token5.type === "NEWLINE" || token5.type === "EOF") {
       break;
@@ -10748,14 +11071,11 @@ function parseColorContent(ctx) {
   const contentResult = parseInlineUntil({ ...ctx, pos }, "COLOR_MARKER");
   pos += contentResult.consumed;
   consumed += contentResult.consumed;
-  if (ctx.tokens[pos]?.type !== "COLOR_MARKER") {
-    return null;
-  }
-  consumed++;
   const color = colorSpec.trim();
   if (color === "" || contentResult.elements.length === 0) {
     return null;
   }
+  consumed += consumeFormattingClose(ctx, close, pos);
   return {
     color: hexifyColor(color),
     elements: contentResult.elements,
@@ -11378,14 +11698,19 @@ function parseSpanContent(ctx, startPos, blockName) {
   const escapedChildren = [];
   const splitSpans = [];
   let foundClose = false;
+  let forcedClose = false;
   let afterBlankLine = false;
   let consumed = 0;
   let pos = startPos;
-  while (pos < ctx.tokens.length) {
+  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
     const token5 = ctx.tokens[pos];
     if (!token5 || token5.type === "EOF") {
       break;
     }
+    if (ctx.scope.tableFormatting?.suppressedClosers.has(pos)) {
+      forcedClose = true;
+      break;
+    }
     const close = parseCloseSpan(ctx, pos);
     if (close.success) {
       pos += close.consumed;
@@ -11410,6 +11735,29 @@ function parseSpanContent(ctx, startPos, blockName) {
     pos += parsed.consumed;
     consumed += parsed.consumed;
   }
+  if (!foundClose && ctx.scope.tableFormatting && (pos === ctx.scope.inlineEnd || forcedClose)) {
+    let depth = 0;
+    for (let next = pos;next < ctx.scope.tableFormatting.end; next++) {
+      const rawEnd = rawRegionEnd(ctx.tokens, next, ctx.scope.tableFormatting.end);
+      if (rawEnd > next) {
+        next = rawEnd - 1;
+        continue;
+      }
+      if (ctx.tokens[next]?.type === "BLOCK_OPEN" && /^span_?$/i.test(ctx.tokens[next + 1]?.value ?? ""))
+        depth++;
+      const close = parseCloseSpan(ctx, next);
+      if (!close.success)
+        continue;
+      if (depth > 0) {
+        depth--;
+        continue;
+      }
+      for (let offset = 0;offset < close.consumed; offset++)
+        ctx.scope.tableFormatting.suppressedClosers.add(next + offset);
+      foundClose = true;
+      break;
+    }
+  }
   return { children, escapedChildren, splitSpans, consumed, foundClose };
 }
 function parseOneSpanChild(ctx, pos, targetChildren) {
@@ -11821,135 +12169,6 @@ var footnoteRule = {
   }
 };
 
-// packages/parser/src/parser/rules/inline/image/attributes.ts
-function parseImageAttributes(ctx, startPos) {
-  const result = parseAttributesRaw(ctx, startPos, false);
-  const link = result.attrs.link ?? null;
-  const { link: _link, ...htmlAttributes } = result.attrs;
-  return {
-    attributes: filterUnsafeAttributes(htmlAttributes),
-    link,
-    consumed: result.consumed
-  };
-}
-
-// packages/parser/src/parser/rules/inline/image/body.ts
-function parseImageSourceText(ctx, startPos) {
-  let pos = startPos;
-  let consumed = 0;
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-  let sourceText = "";
-  while (pos < ctx.tokens.length) {
-    const token5 = ctx.tokens[pos];
-    if (!token5 || token5.type === "WHITESPACE" || token5.type === "BLOCK_CLOSE" || token5.type === "NEWLINE" || token5.type === "EOF") {
-      break;
-    }
-    sourceText += token5.value;
-    pos++;
-    consumed++;
-  }
-  return { sourceText, consumed };
-}
-
-// packages/parser/src/parser/rules/inline/image/syntax.ts
-var IMAGE_BLOCK_NAMES = new Set([
-  "image",
-  "=image",
-  "<image",
-  ">image",
-  "f<image",
-  "f>image",
-  "f=image"
-]);
-function parseImageBlockName(ctx, startPos) {
-  let pos = startPos;
-  let consumed = 0;
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-  const prefixResult = parseImagePrefix(ctx, pos);
-  const prefix = prefixResult.prefix;
-  pos += prefixResult.consumed;
-  consumed += prefixResult.consumed;
-  const nameToken = ctx.tokens[pos];
-  if (!nameToken || nameToken.type !== "TEXT" && nameToken.type !== "IDENTIFIER") {
-    return null;
-  }
-  return { name: prefix + nameToken.value.toLowerCase(), consumed: consumed + 1 };
-}
-function isImageBlockName(blockName) {
-  return IMAGE_BLOCK_NAMES.has(blockName);
-}
-function parseImagePrefix(ctx, pos) {
-  const token5 = ctx.tokens[pos];
-  if (token5?.type === "EQUALS") {
-    return { prefix: "=", consumed: 1 };
-  }
-  if (token5?.type === "TEXT" && token5.value === "<") {
-    return { prefix: "<", consumed: 1 };
-  }
-  if ((token5?.type === "TEXT" || token5?.type === "BLOCKQUOTE_MARKER") && token5.value === ">") {
-    return { prefix: ">", consumed: 1 };
-  }
-  if (token5?.type === "IDENTIFIER" && token5.value.toLowerCase() === "f") {
-    return parseFloatPrefix(ctx, pos + 1);
-  }
-  return { prefix: "", consumed: 0 };
-}
-function parseFloatPrefix(ctx, pos) {
-  const token5 = ctx.tokens[pos];
-  if (token5?.type === "TEXT" && token5.value === "<") {
-    return { prefix: "f<", consumed: 2 };
-  }
-  if ((token5?.type === "TEXT" || token5?.type === "BLOCKQUOTE_MARKER") && token5.value === ">") {
-    return { prefix: "f>", consumed: 2 };
-  }
-  if (token5?.type === "EQUALS") {
-    return { prefix: "f=", consumed: 2 };
-  }
-  return { prefix: "", consumed: 0 };
-}
-
-// packages/parser/src/parser/rules/inline/image/open.ts
-function parseImageOpen(ctx) {
-  if (ctx.tokens[ctx.pos]?.type !== "BLOCK_OPEN") {
-    return null;
-  }
-  let pos = ctx.pos + 1;
-  let consumed = 1;
-  const nameResult = parseImageBlockName(ctx, pos);
-  if (!nameResult || !isImageBlockName(nameResult.name)) {
-    return null;
-  }
-  pos += nameResult.consumed;
-  consumed += nameResult.consumed;
-  const sourceText = parseImageSourceText(ctx, pos);
-  pos += sourceText.consumed;
-  consumed += sourceText.consumed;
-  const attrs = parseImageAttributes(ctx, pos);
-  pos += attrs.consumed;
-  consumed += attrs.consumed;
-  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-    return null;
-  }
-  pos++;
-  consumed++;
-  if (!sourceText.sourceText) {
-    return null;
-  }
-  return {
-    blockName: nameResult.name,
-    sourceText: sourceText.sourceText,
-    link: attrs.link,
-    attributes: attrs.attributes,
-    consumed
-  };
-}
-
 // packages/parser/src/parser/rules/inline/image/source.ts
 function parseImageSource(src) {
   if (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("/")) {
@@ -13000,6 +13219,7 @@ var inlineRules = [
   htmlInlineRule,
   rawRule,
   imageRule,
+  embedBlockRule,
   sizeRule,
   footnoteRule,
   spanRule,