@wdprlib/parser 5.3.0 → 6.0.0

package/src/parser/rules/block/module/rate/index.ts

@@ -1,28 +1,25 @@
-/**
- *
- * Parser rule for the Wikidot `[[module Rate]]` block.
- *
- * Renders a page rating widget. This is a simple module with no attributes
- * and no body content.
- *
- * @module
- */
-
+import type { CustomRateModuleData, RateModuleData } from "@wdprlib/ast";
 import type { ModuleRule } from "../types";
-import type { RateModuleData } from "./types";
 
-/**
- * Module rule for `[[module Rate]]`.
- *
- * Simply produces a `{ module: "rate" }` AST node. The rendering application
- * is responsible for displaying upvote/downvote buttons and the current rating.
- */
+/** The main rating accepts no page, axis, policy, or permission attributes. */
 export const rateModuleRule: ModuleRule = {
   name: "module-rate",
   acceptsNames: ["rate"],
   hasBody: false,
+  parse(_ctx, _pos, args): RateModuleData {
+    return { module: "rate", ref: Object.keys(args).length === 0 ? { kind: "main" } : null };
+  },
+};
 
-  parse(): RateModuleData {
-    return { module: "rate" };
+/** Reference an exact, host-registered key on the displayed page. */
+export const customRateModuleRule: ModuleRule = {
+  name: "module-custom-rate",
+  acceptsNames: ["customrate"],
+  hasBody: false,
+  parse(_ctx, _pos, args): CustomRateModuleData {
+    const key = args.key;
+    const valid =
+      key !== undefined && key !== "" && Object.keys(args).every((name) => name === "key");
+    return { module: "custom-rate", ref: valid ? { kind: "custom", axisKey: key } : null };
   },
 };

package/src/parser/rules/block/module/rate/resolve.ts

@@ -0,0 +1,108 @@
+import type { Element, RatingRef, RatingState, SyntaxTree } from "@wdprlib/ast";
+import { getModuleParseAst, type ModuleParseResult } from "../types";
+import { mapElementChildren } from "../walk";
+import type { RatingsFetcher } from "./types";
+
+function refKey(ref: RatingRef): string {
+  return ref.kind === "main" ? "main" : `custom:${ref.axisKey}`;
+}
+
+/** Resolve once after includes and module expansion, using only the displayed page. */
+export async function resolveRatings(
+  ast: SyntaxTree,
+  fetchRatings?: RatingsFetcher,
+): Promise<SyntaxTree> {
+  const refs = new Map<string, RatingRef>();
+  mapDocument(ast, (element) => {
+    if (isRating(element) && element.data.ref) refs.set(refKey(element.data.ref), element.data.ref);
+    return element;
+  });
+  const states = new Map<string, RatingState>();
+  if (fetchRatings && refs.size > 0) {
+    for (const state of await fetchRatings([...refs.values()])) {
+      const key = refKey(state.ref);
+      if (refs.has(key)) states.set(key, state);
+    }
+  }
+  return mapDocument(ast, (element) => {
+    if (!isRating(element)) return element;
+    const { state: _previous, ...data } = element.data;
+    const state = data.ref ? states.get(refKey(data.ref)) : undefined;
+    return { ...element, data: state ? { ...data, state } : data };
+  });
+}
+
+/** Module-generated source cannot declare ratings, including in its footnote side channel. */
+export function suppressModuleRatings(result: ModuleParseResult): ModuleParseResult {
+  const ast = mapDocument(getModuleParseAst(result), (element) =>
+    isRating(element) ? null : element,
+  );
+  return "ast" in result ? { ...result, ast } : ast;
+}
+
+function isRating(element: Element): element is Extract<Element, { element: "module" }> & {
+  data: Extract<
+    Extract<Element, { element: "module" }>["data"],
+    { module: "rate" | "custom-rate" }
+  >;
+} {
+  return (
+    element.element === "module" &&
+    (element.data.module === "rate" || element.data.module === "custom-rate")
+  );
+}
+
+function mapDocument(ast: SyntaxTree, transform: (element: Element) => Element | null): SyntaxTree {
+  const map = (elements: Element[]): Element[] =>
+    elements.flatMap((original) => {
+      const element = transform(original);
+      if (!element) return [];
+      if (element.element === "if") {
+        return [
+          {
+            ...element,
+            data: {
+              ...element.data,
+              // oxlint-disable-next-line unicorn/no-thenable -- public AST branch name
+              then: map(element.data.then),
+              else: map(element.data.else),
+            },
+          },
+        ];
+      }
+      if (element.element === "ifexpr") {
+        return [
+          {
+            ...element,
+            data: {
+              ...element.data,
+              // oxlint-disable-next-line unicorn/no-thenable -- public AST branch name
+              then: map(element.data.then),
+              else: map(element.data.else),
+            },
+          },
+        ];
+      }
+      if (element.element === "bibliography-block") {
+        return [
+          {
+            ...element,
+            data: {
+              ...element.data,
+              entries: element.data.entries.map((entry) => ({
+                ...entry,
+                key: map(entry.key),
+                value: map(entry.value),
+              })),
+            },
+          },
+        ];
+      }
+      return [mapElementChildren(element, map)];
+    });
+  return {
+    ...ast,
+    elements: map(ast.elements),
+    ...(ast.footnotes ? { footnotes: ast.footnotes.map(map) } : {}),
+  };
+}

package/src/parser/rules/block/module/rate/types.ts

@@ -1,19 +1,9 @@
-/**
- *
- * Type definitions for the Rate module.
- *
- * The `[[module Rate]]` block renders a page rating widget (upvote/downvote buttons).
- * It takes no attributes and has no body.
- *
- * @module
- */
+import type { RatingRef, RatingState } from "@wdprlib/ast";
+export type { RateModuleData, CustomRateModuleData } from "@wdprlib/ast";
 
 /**
- * AST data for a `[[module Rate]]` element.
- *
- * This module has no configurable properties. The rendering application
- * is responsible for displaying the appropriate rating widget.
+ * Read authorized ratings for the displayed page. Omit unknown, disabled, or
+ * inaccessible references. The host owns registration, category policies,
+ * access checks, aggregates, and persistence; rendering must never create data.
  */
-export interface RateModuleData {
-  module: "rate";
-}
+export type RatingsFetcher = (refs: readonly RatingRef[]) => Promise<readonly RatingState[]>;

package/src/parser/rules/block/module/resolution/resolve-async.ts

@@ -28,6 +28,7 @@ import { ModuleDocumentRegistry } from "./document";
 import { collectStyles, mergeCollectedStyles } from "./styles";
 import { createListPagesPager } from "../listpages/resolution/pager";
 import type { ListPagesPaginationState } from "./data-maps";
+import { suppressModuleRatings } from "../rate/resolve";
 
 export type AsyncModuleParseFunction = (source: string) => Promise<ModuleParseResult>;
 
@@ -73,7 +74,7 @@ export async function resolveModulesWithAsyncParse(
   const registry = new ModuleDocumentRegistry();
   registry.register(ast);
   const parse = async (source: string): Promise<SyntaxTree> =>
-    registry.register(await options.parse(source));
+    registry.register(suppressModuleRatings(await options.parse(source)));
 
   const [listPagesData, listUsersData, tagCloudData] = await Promise.all([
     buildListPagesDataMap(

package/src/parser/rules/block/module/resolve.ts

@@ -31,6 +31,7 @@ import {
 import { walkAndResolve } from "./resolution/walk-resolve";
 import { collectStyles, mergeCollectedStyles } from "./resolution/styles";
 import { containsSyntaxFootnoteBlock, ModuleDocumentRegistry } from "./resolution/document";
+import { resolveRatings, suppressModuleRatings } from "./rate/resolve";
 
 const MODULE_SECONDARY_INCLUDE_MAX_ITERATIONS = 5;
 
@@ -188,11 +189,9 @@ export async function resolveModules(
   if (mergedStyles.length > 0) result.styles = mergedStyles;
 
   options.onDiagnostics?.(registry.diagnostics);
-  return registry.finalize(
-    result,
-    finalElements,
-    pageTags,
-    containsSyntaxFootnoteBlock(ast.elements),
+  return resolveRatings(
+    registry.finalize(result, finalElements, pageTags, containsSyntaxFootnoteBlock(ast.elements)),
+    dataProvider.fetchRatings,
   );
 }
 
@@ -203,9 +202,12 @@ function createModuleParseFunction(
 ): ParseFunction {
   const transform = createModuleSourceTransform(options, dataProvider);
   return (source: string) =>
-    registry.register(options.parse(transform ? transform(source) : source), {
-      stripLegacyImplicitFootnoteBlock: true,
-    });
+    registry.register(
+      suppressModuleRatings(options.parse(transform ? transform(source) : source)),
+      {
+        stripLegacyImplicitFootnoteBlock: true,
+      },
+    );
 }
 
 function createModuleSourceTransform(

package/src/parser/rules/block/module/types-common.ts

@@ -17,6 +17,7 @@ import type { ListUsersDataFetcher } from "./listusers/types";
 import type { TagCloudDataFetcher } from "./tagcloud/types";
 import type { IfTagsResolver } from "./iftags/types";
 import type { IncludeFetcher } from "./include/resolve/types";
+import type { RatingsFetcher } from "./rate/types";
 
 /**
  * Callback bag for supplying external data during module resolution.
@@ -29,6 +30,9 @@ import type { IncludeFetcher } from "./include/resolve/types";
  * @group Module Resolution
  */
 export interface DataProvider {
+  /** Read registered ratings for the displayed page; omitted references stay hidden. */
+  fetchRatings?: RatingsFetcher;
+
   /**
    * Fetch page data for `[[module ListPages]]` expansion.
    *

package/src/parser/rules/block/note/boundary.ts

@@ -0,0 +1,88 @@
+import type { Token } from "../../../../lexer";
+import type { ParseContext } from "../../types";
+import { createOpaqueProbe, opaqueRuleEnd } from "../../opaque-probe";
+import { codeBlockRule } from "../code";
+import { mathBlockRule } from "../math";
+import { linkTripleRule } from "../../inline/link-triple";
+import { protectedInlineRegionEnd } from "../../inline/raw/end";
+
+// These constructs are replaced before Note in Wikidot's processing order.
+const opaqueRules = [codeBlockRule, mathBlockRule, linkTripleRule];
+interface NoteBounds {
+  bodyStart: number;
+  close: number;
+  end: number;
+}
+const boundsCache = new WeakMap<readonly Token[], Map<number, NoteBounds | null>>();
+const closeCache = new WeakMap<readonly Token[], Map<string, Map<number, number>>>();
+
+function tagEnd(tokens: readonly Token[], pos: number, name: string, close = false): number {
+  return tokens[pos]?.type === (close ? "BLOCK_END_OPEN" : "BLOCK_OPEN") &&
+    tokens[pos + 1]?.value.toLowerCase() === name &&
+    tokens[pos + 2]?.type === "BLOCK_CLOSE"
+    ? pos + 3
+    : pos;
+}
+
+function findClose(probe: ParseContext, start: number, name: string): number {
+  let byName = closeCache.get(probe.tokens);
+  if (!byName) {
+    byName = new Map();
+    closeCache.set(probe.tokens, byName);
+  }
+  let cache = byName.get(name);
+  if (!cache) {
+    cache = new Map();
+    byName.set(name, cache);
+  }
+  if (cache.has(start)) return cache.get(start)!;
+  const visited: number[] = [];
+  let result = -1;
+  for (let pos = start; pos < probe.tokens.length; pos++) {
+    if (cache.has(pos)) {
+      result = cache.get(pos)!;
+      break;
+    }
+    visited.push(pos);
+    const protectedEnd = protectedInlineRegionEnd(probe.tokens, pos, probe.tokens.length);
+    if (protectedEnd > pos) {
+      pos = protectedEnd - 1;
+      continue;
+    }
+    if (tagEnd(probe.tokens, pos, name, true) > pos) {
+      result = pos;
+      break;
+    }
+    const opaqueEnd = opaqueRuleEnd(probe, pos, opaqueRules, true);
+    if (opaqueEnd > pos) {
+      pos = opaqueEnd - 1;
+      continue;
+    }
+    // Footnote precedes Note and uses its first complete close, without nesting.
+    if (name === "note") {
+      const footnoteStart = tagEnd(probe.tokens, pos, "footnote");
+      if (footnoteStart > pos) {
+        const end = findClose(probe, footnoteStart, "footnote");
+        if (end >= 0) pos = end + 2;
+      }
+    }
+  }
+  // Only visited positions are reusable: opaque interiors have different boundaries.
+  for (const pos of visited) cache.set(pos, result);
+  return result;
+}
+
+export function findNoteBounds(ctx: ParseContext, start: number = ctx.pos): NoteBounds | null {
+  const openEnd = tagEnd(ctx.tokens, start, "note");
+  if (openEnd === start || ctx.tokens[openEnd]?.type !== "NEWLINE") return null;
+  let cache = boundsCache.get(ctx.tokens);
+  if (!cache) {
+    cache = new Map();
+    boundsCache.set(ctx.tokens, cache);
+  }
+  if (cache.has(start)) return cache.get(start)!;
+  const close = findClose(createOpaqueProbe(ctx), openEnd + 1, "note");
+  const result = close < 0 ? null : { bodyStart: openEnd + 1, close, end: close + 3 };
+  cache.set(start, result);
+  return result;
+}

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

@@ -0,0 +1,37 @@
+import type { BlockRule } from "../../types";
+import { parseBlocksUntil } from "../parsing/content";
+import { findNoteBounds } from "./boundary";
+
+const excludedBlockNames = new Set(["note"]);
+
+export const noteRule: BlockRule = {
+  name: "note",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  parse(ctx) {
+    const bounds = findNoteBounds(ctx);
+    if (!bounds) return { success: false };
+    const body = parseBlocksUntil(
+      {
+        ...ctx,
+        tokens: ctx.tokens.slice(bounds.bodyStart, bounds.close),
+        pos: 0,
+        scope: {
+          ...ctx.scope,
+          inlineEnd: undefined,
+          tableFormatting: undefined,
+          blockCloseCondition: undefined,
+        },
+      },
+      () => false,
+      { excludedBlockNames },
+    );
+    return {
+      success: true,
+      consumed: bounds.end - ctx.pos,
+      elements: [
+        { element: "container", data: { type: "note", attributes: {}, elements: body.elements } },
+      ],
+    };
+  },
+};

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

@@ -1,3 +1,5 @@
+import { markUnparsedDivStart } from "../../../postprocess/divAdjacentParagraph";
+import { isDivClose } from "../div/close";
 /**
  * Paragraph rule
  *
@@ -8,6 +10,7 @@ import type { Element } from "@wdprlib/ast";
 import type { BlockRule, ParseContext, RuleResult } from "../../types";
 import { parseInlineContent } from "./content";
 import { normalizeParagraphElements } from "./normalize";
+import { isPreservedLeadingLineBreak } from "../../inline/parsing/preserved-line-break";
 
 /**
  * Paragraph is the fallback block rule.
@@ -23,18 +26,19 @@ export const paragraphRule: BlockRule = {
 
   parse(ctx: ParseContext): RuleResult<Element> {
     const result = parseInlineContent(ctx);
-    if (result.elements.length === 0) {
+    if (result.consumed === 0) {
       return { success: false };
     }
 
     const elements = normalizeParagraphElements(result.elements);
     if (elements.length === 0) {
-      return { success: false };
+      return { success: true, elements: [], consumed: result.consumed };
     }
 
     const nextPos = ctx.pos + result.consumed;
     const nextToken = ctx.tokens[nextPos];
     if (nextToken?.type === "COLON" && nextToken.lineStart) {
+      if (isPreservedLeadingLineBreak(elements[0])) elements[0] = { element: "line-break" };
       return {
         success: true,
         elements: [...elements, { element: "line-break" }],
@@ -42,9 +46,11 @@ export const paragraphRule: BlockRule = {
       };
     }
 
+    const wrapped = wrapParagraphElements(elements);
+    if (isDivClose(ctx)) markUnparsedDivStart(wrapped);
     return {
       success: true,
-      elements: wrapParagraphElements(elements),
+      elements: wrapped,
       consumed: result.consumed,
     };
   },
@@ -57,7 +63,8 @@ export function wrapParagraphElements(elements: Element[]): Element[] {
   let bare = false;
   const flush = (trimBreaks = false) => {
     const content = trimBreaks ? normalizeParagraphElements(group) : group;
-    while (content[0]?.element === "line-break") content.shift();
+    while (content[0]?.element === "line-break" && !isPreservedLeadingLineBreak(content[0]))
+      content.shift();
     while (content.length) {
       const last = content.at(-1)!;
       if (last.element !== "text" || last.data.trim() !== "") break;
@@ -66,6 +73,7 @@ export function wrapParagraphElements(elements: Element[]): Element[] {
     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 (isPreservedLeadingLineBreak(content[0])) content[0] = { element: "line-break" };
     if (content.length)
       output.push(
         ...(bare || content.some((el) => el.element === "image")

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

@@ -1,5 +1,6 @@
 import type { Element } from "@wdprlib/ast";
 import { processCloseSpanMarkers } from "./span-markers";
+import { isPreservedLeadingLineBreak } from "../../inline/parsing/preserved-line-break";
 
 type PreservedLineBreak = Extract<Element, { element: "line-break" }> & {
   _preservedTrailingBreak?: boolean;
@@ -44,7 +45,11 @@ function removeTrailingWhitespaceText(elements: Element[]): void {
 
 function removeLeadingLineBreaks(elements: Element[]): Element[] {
   let first = 0;
-  while (first < elements.length && elements[first]?.element === "line-break") {
+  while (
+    first < elements.length &&
+    elements[first]?.element === "line-break" &&
+    !isPreservedLeadingLineBreak(elements[first])
+  ) {
     first++;
   }
 

package/src/parser/rules/block/parsing/block-item.ts

@@ -21,7 +21,7 @@ export function parseBlockItem(ctx: ParseContext): BlockItemResult {
   }
 
   const fallback = ctx.blockFallbackRule.parse(ctx);
-  if (fallback.success && fallback.elements.length > 0) {
+  if (fallback.success) {
     return { elements: fallback.elements, consumed: fallback.consumed };
   }
 

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

@@ -101,7 +101,7 @@ export function parseBlocksUntil(
     blockCtx.scope = blockScope;
 
     const result = parseBlockItem(blockCtx);
-    elements.push(...result.elements);
+    for (const element of result.elements) elements.push(element);
     consumed += result.consumed;
     pos += result.consumed;
   }

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

@@ -1,3 +1,5 @@
+import { stripAutomaticLineBreak } from "../../inline/parsing/automatic-line-break";
+import { createAutomaticLineBreak } from "../../inline/parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { getCandidateInlineRules } from "../../inline/utils";
@@ -58,7 +60,7 @@ export function parseInlineContentUntil(
       consumed += newlineResult.consumed;
       pos += newlineResult.consumed;
       if (newlineResult.addLineBreak) {
-        elements.push({ element: "line-break" });
+        elements.push(createAutomaticLineBreak(token));
       }
       continue;
     }
@@ -69,7 +71,7 @@ export function parseInlineContentUntil(
     for (const rule of getCandidateBlockRules(blockRules, token)) {
       const result = rule.parse(blockCtx);
       if (result.success) {
-        elements.push(...result.elements);
+        for (const element of result.elements) elements.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;
@@ -84,7 +86,8 @@ export function parseInlineContentUntil(
     for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        elements.push(...result.elements);
+        stripAutomaticLineBreak(elements, result.stripLeadingLineBreak);
+        for (const element of result.elements) elements.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;

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

@@ -1,3 +1,4 @@
+import { stripAutomaticLineBreak } from "../../../inline/parsing/automatic-line-break";
 import { protectedInlineRegionEnd } from "../../../inline/raw/end";
 import type { Element, TableCell } from "@wdprlib/ast";
 import type { ParseContext } from "../../../types";
@@ -85,7 +86,8 @@ export function parseTableCell(
     for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        children.push(...result.elements);
+        stripAutomaticLineBreak(children, result.stripLeadingLineBreak);
+        for (const element of result.elements) children.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;

package/src/parser/rules/block/table-block/cell-content/index.ts

@@ -69,7 +69,7 @@ export function parseCellContent(
     for (const rule of getCandidateInlineRules(ctx.inlineRules, token.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        content.addInlineElements(result.elements);
+        content.addInlineElements(result.elements, result.stripLeadingLineBreak);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;

package/src/parser/rules/block/table-block/cell-content/segments.ts

@@ -1,8 +1,10 @@
+import type { Token } from "../../../../../lexer";
+import { stripAutomaticLineBreak } from "../../../inline/parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 
 export interface CellContentAccumulator {
   addInline(element: Element): void;
-  addInlineElements(elements: Element[]): void;
+  addInlineElements(elements: Element[], stripLeadingLineBreak?: Token): void;
   addBlockElements(elements: Element[]): void;
   addParagraphBreak(): void;
   closeInlineSegmentBeforeBlock(): void;
@@ -40,7 +42,8 @@ export function createCellContentAccumulator(): CellContentAccumulator {
     addInline(element: Element) {
       currentSegment.push(element);
     },
-    addInlineElements(nextElements: Element[]) {
+    addInlineElements(nextElements: Element[], stripLeadingLineBreak?: Token) {
+      stripAutomaticLineBreak(currentSegment, stripLeadingLineBreak);
       currentSegment.push(...nextElements);
     },
     addBlockElements(blockElements: Element[]) {

package/src/parser/rules/block/table-block/cell-newline.ts

@@ -1,3 +1,4 @@
+import { createAutomaticLineBreak } from "../../inline/parsing/automatic-line-break";
 import type { ParseContext } from "../../types";
 import type { CellContentAccumulator } from "./cell-content/segments";
 
@@ -40,7 +41,7 @@ export function consumeCellContentNewline(
   }
 
   if (!content.isEmpty()) {
-    content.addInline({ element: "line-break" });
+    content.addInline(createAutomaticLineBreak(ctx.tokens[startPos]!));
   }
 
   return { consumed };

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

@@ -1,11 +1,13 @@
 import type { Element } from "@wdprlib/ast";
-import type { TokenType } from "../../../lexer";
+import type { Token, TokenType } from "../../../lexer";
 import type { ParseContext } from "./parse-context";
 
 /**
  * Result of a rule attempt.
  */
-export type RuleResult<T> = { success: true; elements: T[]; consumed: number } | { success: false };
+export type RuleResult<T> =
+  | { success: true; elements: T[]; consumed: number; stripLeadingLineBreak?: Token }
+  | { success: false };
 
 /**
  * Block rule interface.

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

@@ -10,6 +10,8 @@ import type { ParseContext } from "./parse-context";
 export interface ScopeContext {
   /** Exclusive token boundary inherited by nested inline rules. */
   readonly inlineEnd?: number;
+  /** Keep bare addresses as text inside an existing anchor. */
+  readonly suppressEmailLinks?: boolean;
   /** Closing delimiters paired across cells of the current pipe table. */
   readonly tableFormatting?: { end: number; suppressedClosers: Set<number> };
   /**

package/src/parser/rules/inline/anchor/child.ts

@@ -1,3 +1,4 @@
+import type { Token } from "../../../../lexer";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { inlineRules } from "../index";
@@ -6,6 +7,7 @@ import { getCandidateInlineRules } from "../utils";
 export interface AnchorChildResult {
   elements: Element[];
   consumed: number;
+  stripLeadingLineBreak?: Token;
 }
 
 export function parseAnchorChild(ctx: ParseContext, pos: number): AnchorChildResult {
@@ -14,11 +16,15 @@ export function parseAnchorChild(ctx: ParseContext, pos: number): AnchorChildRes
     return { elements: [], consumed: 0 };
   }
 
-  const inlineCtx: ParseContext = { ...ctx, pos };
+  const inlineCtx: ParseContext = {
+    ...ctx,
+    pos,
+    scope: { ...ctx.scope, suppressEmailLinks: true },
+  };
   for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
     const result = rule.parse(inlineCtx);
     if (result.success) {
-      return { elements: result.elements, consumed: result.consumed };
+      return result;
     }
   }
 

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

@@ -1,3 +1,4 @@
+import { stripAutomaticLineBreak } from "../parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { parseAnchorChild } from "./child";
@@ -50,7 +51,8 @@ export function parseAnchorContent(
     }
 
     const child = parseAnchorChild(ctx, pos);
-    children.push(...child.elements);
+    stripAutomaticLineBreak(children, child.stripLeadingLineBreak);
+    for (const element of child.elements) children.push(element);
     pos += child.consumed;
     consumed += child.consumed;
   }