@wdprlib/parser 5.1.6 → 5.2.0

package/src/parser/rules/block/definition-list/item-value.ts

@@ -27,17 +27,8 @@ export function parseDefinitionItemValue(
     }
 
     if (token.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: ParseContext = { ...ctx, pos };

package/src/parser/rules/block/definition-list/items.ts

@@ -21,8 +21,7 @@ export interface ParsedDefinitionItem {
  *
  * The function expects `startPos` to point at a line-start COLON token.
  * It consumes the first colon, mandatory whitespace, key tokens up to
- * the second colon, then value tokens until a double newline, a new entry,
- * or end of input.
+ * the second colon, then value tokens until a newline or end of input.
  */
 export function parseDefinitionItem(
   ctx: ParseContext,

package/src/parser/rules/block/embed-block/index.ts

@@ -8,9 +8,6 @@
  * between the tags is stored verbatim as an `embed-block` element. Validation
  * and sanitisation are expected to happen at rendering time or on the server.
  *
- * The embed block is wrapped in a paragraph container in the AST, matching
- * Wikidot's rendering behaviour where embeds sit inside `<p>` tags.
- *
  * If no closing tag is found, the rule fails to prevent consuming the rest
  * of the document.
  *
@@ -18,6 +15,8 @@
  */
 import type { Element } from "@wdprlib/ast";
 import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { parseInlineUntil } from "../../inline/utils";
+import { normalizeParagraphElements } from "../paragraph/normalize";
 import { currentToken } from "../../types";
 import { collectEmbedContent, consumeEmbedClose } from "./content";
 import { parseEmbedBlockOpen } from "./open";
@@ -34,6 +33,8 @@ export const embedBlockRule: BlockRule = {
   name: "embed-block",
   startTokens: ["BLOCK_OPEN"],
   requiresLineStart: false,
+  preservesPrecedingLineBreak: true,
+  isStartPattern: (ctx, pos) => parseEmbedBlockOpen(ctx, pos) !== null,
 
   parse(ctx: ParseContext): RuleResult<Element> {
     const openToken = currentToken(ctx);
@@ -53,12 +54,17 @@ export const embedBlockRule: BlockRule = {
     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 };
     }
 
@@ -66,26 +72,20 @@ export const embedBlockRule: BlockRule = {
     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[] = [
+      { 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 };
   },
 };

package/src/parser/rules/block/heading/index.ts

@@ -55,6 +55,13 @@ export const headingRule: BlockRule = {
     const inlineCtx: ParseContext = { ...ctx, pos };
     const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
     const children: Element[] = 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;
 

package/src/parser/rules/block/paragraph/index.ts

@@ -44,17 +44,48 @@ export const paragraphRule: BlockRule = {
 
     return {
       success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "paragraph",
-            attributes: {},
-            elements,
-          },
-        },
-      ],
+      elements: wrapParagraphElements(elements),
       consumed: result.consumed,
     };
   },
 };
+
+/** Block images split paragraphs; ordinary images suppress the surrounding p. */
+export function wrapParagraphElements(elements: Element[]): Element[] {
+  const output: Element[] = [];
+  let group: Element[] = [];
+  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" as const,
+                data: { type: "paragraph" as const, 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;
+}

package/src/parser/rules/block/parsing/content.ts

@@ -52,7 +52,10 @@ export function parseBlocksUntil(
   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,
@@ -106,6 +109,20 @@ export function parseBlocksUntil(
   return { elements, consumed };
 }
 
+/**
+ * An enclosing container's exclusions stay in force in its body: Wikidot keeps
+ * a `[[collapsible]]` nested in a div literal when the div itself sits in a
+ * collapsible.
+ */
+function mergeExcludedBlockNames(
+  inherited: ReadonlySet<string> | undefined,
+  added: ReadonlySet<string> | undefined,
+): ReadonlySet<string> | undefined {
+  if (!inherited?.size) return added;
+  if (!added?.size) return inherited;
+  return new Set([...inherited, ...added]);
+}
+
 function getExcludedBlockRules(
   blockRules: ParseContext["blockRules"],
   excluded: ReadonlySet<string>,

package/src/parser/rules/block/table/pipe/cell.ts

@@ -1,3 +1,4 @@
+import { protectedInlineRegionEnd } from "../../../inline/raw/end";
 import type { Element, TableCell } from "@wdprlib/ast";
 import type { ParseContext } from "../../../types";
 import { getCandidateInlineRules } from "../../../inline/utils";
@@ -20,7 +21,35 @@ export function parseTableCell(
   }
 
   const { inlineRules } = ctx;
-  const inlineCtx: ParseContext = { ...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 token = ctx.tokens[inlineEnd];
+    if (!token || token.type === "EOF" || token.type === "NEWLINE" || isPipeTableToken(token.type))
+      break;
+    if (
+      token.type === "WHITESPACE" &&
+      ctx.tokens[inlineEnd + 1]?.type === "UNDERSCORE" &&
+      ctx.tokens[inlineEnd + 2]?.type === "NEWLINE"
+    )
+      inlineEnd += 3;
+    else inlineEnd++;
+  }
+  const inlineCtx: ParseContext = {
+    ...ctx,
+    pos,
+    scope: {
+      ...ctx.scope,
+      inlineEnd,
+      tableFormatting: isPipeTableToken(ctx.tokens[inlineEnd]?.type ?? "EOF")
+        ? ctx.scope.tableFormatting
+        : undefined,
+    },
+  };
 
   while (pos < ctx.tokens.length) {
     const token = ctx.tokens[pos];
@@ -31,6 +60,12 @@ export function parseTableCell(
       break;
     }
 
+    if (ctx.scope.tableFormatting?.suppressedClosers.has(pos)) {
+      pos++;
+      consumed++;
+      continue;
+    }
+
     if (tryConsumeUnderscoreLineBreak(ctx, pos, children)) {
       pos += 3;
       consumed += 3;

package/src/parser/rules/block/table/pipe/row.ts

@@ -1,3 +1,4 @@
+import { protectedInlineRegionEnd } from "../../../inline/raw/end";
 import type { TableCell, TableRow } from "@wdprlib/ast";
 import type { ParseContext } from "../../../types";
 import { parseCellStart } from "./cell-start";
@@ -8,6 +9,25 @@ export function parsePipeTableRows(
   ctx: ParseContext,
   startPos: number,
 ): { rows: TableRow[]; consumed: number } {
+  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: ParseContext = {
+    ...ctx,
+    scope: { ...ctx.scope, tableFormatting: { end, suppressedClosers: new Set() } },
+  };
   const rows: TableRow[] = [];
   let pos = startPos;
   let consumed = 0;
@@ -19,7 +39,7 @@ export function parsePipeTableRows(
       break;
     }
 
-    const rowResult = parseTableRow(ctx, pos);
+    const rowResult = parseTableRow(tableCtx, pos);
     rows.push(rowResult.row);
     pos += rowResult.consumed;
     consumed += rowResult.consumed;

package/src/parser/rules/block/toc/element.ts

@@ -1,10 +1,10 @@
 import type { Alignment, Element } from "@wdprlib/ast";
 
-export function createTocElement(align: Alignment | null): Element {
+export function createTocElement(align: Alignment | null, title: string | undefined): Element {
   return {
     element: "table-of-contents",
     data: {
-      attributes: {},
+      attributes: title === undefined ? {} : { title },
       align,
     },
   };

package/src/parser/rules/block/toc/index.ts

@@ -6,7 +6,7 @@
  * - [[f<toc ...]] - float left
  * - [[f>toc ...]] - float right
  *
- * Note: Wikidot ignores attributes on [[toc]] (class, style, id are not applied)
+ * The title attribute overrides the heading; class, style, and id are ignored.
  * [[>toc]] and [[<toc]] are invalid in Wikidot and not supported.
  */
 import type { Element } from "@wdprlib/ast";
@@ -37,7 +37,7 @@ export const tocRule: BlockRule = {
 
     return {
       success: true,
-      elements: [createTocElement(openResult.align)],
+      elements: [createTocElement(openResult.align, openResult.title)],
       consumed: openResult.consumed,
     };
   },

package/src/parser/rules/block/toc/open.ts

@@ -1,8 +1,10 @@
 import type { Alignment } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
+import { parseAttributes } from "../utils";
 
 export interface TocOpenResult {
   align: Alignment | null;
+  title: string | undefined;
   consumed: number;
 }
 
@@ -48,7 +50,8 @@ export function parseTocOpen(ctx: ParseContext, startPos: number): TocOpenResult
     return null;
   }
 
-  pos = skipUntilClose(ctx, pos);
+  const attributes = parseAttributes(ctx, pos);
+  pos += attributes.consumed;
 
   if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
     return null;
@@ -56,27 +59,11 @@ export function parseTocOpen(ctx: ParseContext, startPos: number): TocOpenResult
 
   return {
     align,
+    title: attributes.attrs.title,
     consumed: pos + 1 - startPos,
   };
 }
 
-function skipUntilClose(ctx: ParseContext, startPos: number): number {
-  let pos = startPos;
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (
-      !token ||
-      token.type === "BLOCK_CLOSE" ||
-      token.type === "NEWLINE" ||
-      token.type === "EOF"
-    ) {
-      break;
-    }
-    pos++;
-  }
-  return pos;
-}
-
 function isNameToken(
   token: ParseContext["tokens"][number] | undefined,
 ): token is ParseContext["tokens"][number] & { type: "TEXT" | "IDENTIFIER" } {

package/src/parser/rules/contracts/scope.ts

@@ -8,6 +8,10 @@ import type { ParseContext } from "./parse-context";
  * expressed as a replacement: `ctx.scope = { ...ctx.scope, X: ... }`.
  */
 export interface ScopeContext {
+  /** Exclusive token boundary inherited by nested inline rules. */
+  readonly inlineEnd?: number;
+  /** Closing delimiters paired across cells of the current pipe table. */
+  readonly tableFormatting?: { end: number; suppressedClosers: Set<number> };
   /**
    * Close condition for the current block. The paragraph parser calls
    * it to decide when to stop collecting inline content.

package/src/parser/rules/inline/bold.ts

@@ -3,8 +3,8 @@
  * Parses the Wikidot bold formatting syntax: `**text**`.
  *
  * Bold text is delimited by double asterisks. The opening and closing
- * markers must appear on the same line; if no closing `**` is found
- * before a newline, the opening marker is emitted as literal text.
+ * markers must appear within the same paragraph; if no closing `**` is found
+ * before a block boundary, the opening marker is emitted as literal text.
  *
  * Wikidot behavior for empty bold (`****`): the markers and their
  * (empty) content are discarded entirely, producing no output.
@@ -18,13 +18,13 @@
  */
 import type { Element } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { parseSameLineDelimitedContainer } from "./formatting/container";
+import { parseDelimitedContainer } from "./formatting/container";
 
 /**
  * Inline rule for parsing `**bold**` formatting.
  *
  * Triggered by a `BOLD_MARKER` token (`**`). The rule checks for a
- * matching closing marker on the same line, then recursively parses
+ * matching closing marker within the same paragraph, then recursively parses
  * inline content between the markers.
  *
  * When no closing marker is found, the opening `**` is treated as
@@ -44,6 +44,6 @@ export const boldRule: InlineRule = {
    *          fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    return parseSameLineDelimitedContainer(ctx, "BOLD_MARKER", "bold", { discardEmpty: true });
+    return parseDelimitedContainer(ctx, "BOLD_MARKER", "bold", { discardEmpty: true });
   },
 };

package/src/parser/rules/inline/color/syntax.ts

@@ -1,6 +1,6 @@
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
-import { hasClosingMarkerBeforeNewline } from "../../types";
+import { findFormattingClose, consumeFormattingClose } from "../formatting/close";
 import { parseInlineUntil } from "../utils";
 
 export interface ColorContent {
@@ -10,7 +10,8 @@ export interface ColorContent {
 }
 
 export function parseColorContent(ctx: ParseContext): ColorContent | null {
-  if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "COLOR_MARKER")) {
+  const close = findFormattingClose(ctx, ctx.pos + 1, "COLOR_MARKER");
+  if (close === null) {
     return null;
   }
 
@@ -18,7 +19,7 @@ export function parseColorContent(ctx: ParseContext): ColorContent | null {
   let consumed = 1;
   let colorSpec = "";
 
-  while (pos < ctx.tokens.length) {
+  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
     const token = ctx.tokens[pos];
     if (
       !token ||
@@ -44,16 +45,12 @@ export function parseColorContent(ctx: ParseContext): ColorContent | null {
   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,

package/src/parser/rules/inline/formatting/close.ts

@@ -0,0 +1,39 @@
+import { protectedInlineRegionEnd } from "../raw/end";
+import type { TokenType } from "../../../../lexer";
+import type { ParseContext } from "../../types";
+import { getParagraphNewlineBoundary } from "../parsing/paragraph-boundary";
+
+export function findFormattingClose(
+  ctx: ParseContext,
+  start: number,
+  marker: TokenType,
+): number | null {
+  const table = ctx.scope.tableFormatting;
+  const end = table?.end ?? ctx.scope.inlineEnd ?? ctx.tokens.length;
+  for (let pos = start; pos < end; pos++) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF" || ctx.scope.blockCloseCondition?.({ ...ctx, pos }))
+      return null;
+    if (
+      !table &&
+      token.type === "NEWLINE" &&
+      getParagraphNewlineBoundary(ctx, pos, true).shouldBreak
+    )
+      return null;
+    if (token.type === marker && !table?.suppressedClosers.has(pos)) return pos;
+    const protectedEnd = protectedInlineRegionEnd(ctx.tokens, pos, end);
+    if (protectedEnd > pos) pos = protectedEnd - 1;
+  }
+  return null;
+}
+
+export function consumeFormattingClose(
+  ctx: ParseContext,
+  close: number,
+  contentEnd: number,
+): number {
+  if (close === contentEnd) return 1;
+  // Wikidot closes formatting at the cell edge and suppresses its later delimiter.
+  ctx.scope.tableFormatting?.suppressedClosers.add(close);
+  return 0;
+}

package/src/parser/rules/inline/formatting/container.ts

@@ -1,7 +1,8 @@
 import type { Element, StringContainerType } from "@wdprlib/ast";
 import type { TokenType } from "../../../../lexer";
 import type { ParseContext, RuleResult } from "../../types";
-import { currentToken, hasClosingMarkerBeforeNewline } from "../../types";
+import { currentToken } from "../../types";
+import { findFormattingClose, consumeFormattingClose } from "./close";
 import { parseInlineUntil } from "../utils";
 
 export function createInlineContainer(type: StringContainerType, elements: Element[]): Element {
@@ -15,7 +16,7 @@ export function createInlineContainer(type: StringContainerType, elements: Eleme
   };
 }
 
-export function parseSameLineDelimitedContainer(
+export function parseDelimitedContainer(
   ctx: ParseContext,
   closeToken: TokenType,
   type: StringContainerType,
@@ -23,7 +24,8 @@ export function parseSameLineDelimitedContainer(
 ): RuleResult<Element> {
   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 }],
@@ -32,7 +34,8 @@ export function parseSameLineDelimitedContainer(
   }
 
   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 {

package/src/parser/rules/inline/index.ts

@@ -1,3 +1,4 @@
+import { embedBlockRule } from "../block/embed-block";
 /**
  *
  * Central registry and priority-ordered list of all inline parsing rules.
@@ -130,6 +131,7 @@ export const inlineRules: InlineRule[] = [
   htmlInlineRule,
   rawRule,
   imageRule,
+  embedBlockRule,
   sizeRule,
   footnoteRule,
   spanRule,

package/src/parser/rules/inline/italic.ts

@@ -3,8 +3,8 @@
  * Parses the Wikidot italic formatting syntax: `//text//`.
  *
  * Italic text is delimited by double forward slashes. The opening and
- * closing markers must appear on the same line. If no closing `//` is
- * found before a newline, the opening marker is emitted as literal text.
+ * closing markers must appear within the same paragraph. If no closing `//` is
+ * found before a block boundary, the opening marker is emitted as literal text.
  *
  * Unlike bold (which discards empty markers), italic markers with empty
  * content (`////`) still produce an italic container, matching Wikidot's
@@ -18,13 +18,13 @@
  */
 import type { Element } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { parseSameLineDelimitedContainer } from "./formatting/container";
+import { parseDelimitedContainer } from "./formatting/container";
 
 /**
  * Inline rule for parsing `//italic//` formatting.
  *
  * Triggered by an `ITALIC_MARKER` token (`//`). Checks for a matching
- * closing marker on the same line, then recursively parses inline content.
+ * closing marker within the same paragraph, then recursively parses inline content.
  *
  * When no closing marker is found, the opening `//` is treated as
  * literal text.
@@ -41,6 +41,6 @@ export const italicRule: InlineRule = {
    *          with `type: "italics"`, or a text fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    return parseSameLineDelimitedContainer(ctx, "ITALIC_MARKER", "italics");
+    return parseDelimitedContainer(ctx, "ITALIC_MARKER", "italics");
   },
 };

package/src/parser/rules/inline/monospace.ts

@@ -3,8 +3,8 @@
  * Parses the Wikidot monospace (teletype) formatting syntax: `{{text}}`.
  *
  * Monospace text is delimited by double curly braces. The opening and
- * closing markers must appear on the same line. If no closing `}}`
- * is found before a newline, the opening marker is emitted as literal text.
+ * closing markers must appear within the same paragraph. If no closing `}}`
+ * is found before a block boundary, the opening marker is emitted as literal text.
  *
  * Note: the opening marker is `MONO_MARKER` (`{{`) and the closing marker
  * is `MONO_CLOSE` (`}}`). These are distinct token types because `{` and
@@ -21,13 +21,13 @@
  */
 import type { Element } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { parseSameLineDelimitedContainer } from "./formatting/container";
+import { parseDelimitedContainer } from "./formatting/container";
 
 /**
  * Inline rule for parsing `{{monospace}}` formatting.
  *
  * Triggered by a `MONO_MARKER` token (`{{`). Checks for a matching
- * `MONO_CLOSE` (`}}`) on the same line, then recursively parses
+ * `MONO_CLOSE` (`}}`) within the same paragraph, then recursively parses
  * inline content between the markers.
  *
  * When no closing marker is found, the opening `{{` is treated as
@@ -45,6 +45,6 @@ export const monospaceRule: InlineRule = {
    *          with `type: "monospace"`, or a text fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    return parseSameLineDelimitedContainer(ctx, "MONO_CLOSE", "monospace");
+    return parseDelimitedContainer(ctx, "MONO_CLOSE", "monospace");
   },
 };