@wdprlib/parser 5.1.6 → 5.3.0

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");
   },
 };

package/src/parser/rules/inline/parsing/block-start-predicates.ts

@@ -1,3 +1,4 @@
+import { parseImageOpen } from "../image/open";
 import type { ParseContext } from "../../types";
 import { BLOCK_START_TOKEN_SET } from "../../../constants";
 import {
@@ -26,6 +27,7 @@ export function isParagraphBreakingBlockStart(
   }
 
   return (
+    !parseImageOpen({ ...ctx, pos: nextPos }) &&
     !isOrphanCloseSpan(ctx, nextPos) &&
     !isAnchorName(ctx, nextPos) &&
     !isInvalidBlockOpen(ctx, nextPos) &&

package/src/parser/rules/inline/parsing/inline-content.ts

@@ -1,3 +1,4 @@
+import { protectedInlineRegionEnd } from "../raw/end";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import {
@@ -32,31 +33,53 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
   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: ParseContext = {
     ...ctx,
     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 token = ctx.tokens[pos];
     if (!token || token.type === "EOF") {
       break;
     }
 
-    if (paragraphMode && ctx.scope.blockCloseCondition) {
+    if (ctx.scope.blockCloseCondition) {
       const checkCtx: ParseContext = { ...ctx, pos };
       if (ctx.scope.blockCloseCondition(checkCtx)) {
         break;
       }
     }
 
-    if (!paragraphMode && token.type === "NEWLINE") {
+    if (!multiline && token.type === "NEWLINE") {
       break;
     }
 
-    if (paragraphMode && token.type === "NEWLINE") {
+    if (multiline && token.type === "NEWLINE" && !ctx.scope.tableFormatting) {
       const boundary = getParagraphNewlineBoundary(ctx, pos, nodes.length > 0);
       if (boundary.shouldBreak) {
         if (boundary.preservePrecedingLineBreak) {
@@ -68,6 +91,12 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
       }
     }
 
+    if (ctx.scope.tableFormatting?.suppressedClosers.has(pos)) {
+      pos++;
+      consumed++;
+      continue;
+    }
+
     if (token.type === endType) {
       break;
     }
@@ -96,6 +125,20 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
     for (const rule of getCandidateInlineRules(inlineRules, token.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;
@@ -113,3 +156,14 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
 
   return { elements: nodes, consumed };
 }
+
+const FORMATTING_CLOSE_TOKENS: ReadonlySet<string> = new Set([
+  "BOLD_MARKER",
+  "ITALIC_MARKER",
+  "UNDERLINE_MARKER",
+  "STRIKE_MARKER",
+  "SUPER_MARKER",
+  "SUB_MARKER",
+  "MONO_CLOSE",
+  "COLOR_MARKER",
+]);

package/src/parser/rules/inline/raw/end.ts

@@ -0,0 +1,28 @@
+import type { Token } from "../../../../lexer";
+
+/** Exclusive end of a complete single-line raw region, or the original position. */
+export function rawRegionEnd(tokens: readonly Token[], start: number, end: number): number {
+  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;
+}
+
+/** Raw text and complete comments shield delimiters from their enclosing rule. */
+export function protectedInlineRegionEnd(
+  tokens: readonly Token[],
+  start: number,
+  end: number,
+): number {
+  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;
+}

package/src/parser/rules/inline/span/content.ts

@@ -1,3 +1,4 @@
+import { rawRegionEnd } from "../raw/end";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { inlineRules } from "../../index";
@@ -24,16 +25,21 @@ export function parseSpanContent(
   const escapedChildren: Element[] = [];
   const splitSpans: Element[][] = [];
   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 token = ctx.tokens[pos];
     if (!token || token.type === "EOF") {
       break;
     }
 
+    if (ctx.scope.tableFormatting?.suppressedClosers.has(pos)) {
+      forcedClose = true;
+      break;
+    }
     const close = parseCloseSpan(ctx, pos);
     if (close.success) {
       pos += close.consumed;
@@ -70,6 +76,31 @@ export function parseSpanContent(
     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 };
 }
 

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

@@ -6,7 +6,7 @@
  * token has dual meaning in Wikidot: it can be either a strikethrough
  * marker or an em-dash. The disambiguation rule is:
  *
- * - If a matching closing `--` is found on the same line AND the closing
+ * - If a matching closing `--` is found within the same paragraph AND the closing
  *   marker is NOT preceded by whitespace, it is treated as strikethrough.
  * - Otherwise, the `--` is converted to an em-dash character (U+2014).
  *

package/src/parser/rules/inline/strikethrough/parse.ts

@@ -1,14 +1,7 @@
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext, RuleResult } from "../../types";
-import { createInlineContainer } from "../formatting/container";
-import { parseInlineUntil } from "../utils";
+import { parseDelimitedContainer } from "../formatting/container";
 
 export function parseStrikethroughContent(ctx: ParseContext): RuleResult<Element> {
-  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");
 }

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

@@ -1,24 +1,7 @@
 import type { ParseContext } from "../../types";
+import { findFormattingClose } from "../formatting/close";
 
-/**
- * Returns true when the current `--` can be parsed as strikethrough.
- */
 export function hasValidStrikethroughClose(ctx: ParseContext): boolean {
-  let pos = ctx.pos + 1;
-  let prevWasWhitespace = false;
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
-      return false;
-    }
-
-    if (token.type === "STRIKE_MARKER") {
-      return !prevWasWhitespace;
-    }
-
-    prevWasWhitespace = token.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";
 }

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

@@ -3,8 +3,8 @@
  * Parses the Wikidot subscript formatting syntax: `,,text,,`.
  *
  * Subscript text is delimited by double commas. 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.
  *
  * Empty subscript (`,,,,`) is silently discarded by Wikidot (produces
  * no output), matching the behavior of bold and superscript.
@@ -17,13 +17,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 `,,subscript,,` formatting.
  *
  * Triggered by a `SUB_MARKER` token (`,,`). Checks for a matching
- * closing marker on the same line, then recursively parses inline
+ * 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
@@ -42,6 +42,6 @@ export const subscriptRule: InlineRule = {
    *          text fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    return parseSameLineDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
+    return parseDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
   },
 };

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

@@ -3,8 +3,8 @@
  * Parses the Wikidot superscript formatting syntax: `^^text^^`.
  *
  * Superscript text is delimited by double carets. 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.
  *
  * Empty superscript (`^^^^`) is silently discarded by Wikidot (produces
  * no output), matching the behavior of bold and subscript.
@@ -17,13 +17,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 `^^superscript^^` formatting.
  *
  * Triggered by a `SUPER_MARKER` token (`^^`). Checks for a matching
- * closing marker on the same line, then recursively parses inline
+ * 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
@@ -42,7 +42,7 @@ export const superscriptRule: InlineRule = {
    *          text fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    return parseSameLineDelimitedContainer(ctx, "SUPER_MARKER", "superscript", {
+    return parseDelimitedContainer(ctx, "SUPER_MARKER", "superscript", {
       discardEmpty: true,
     });
   },