@wdprlib/parser 5.2.0 → 5.4.0

package/src/parser/rules/block/module/listpages/resolution/wrapper.ts

@@ -1,13 +1,16 @@
 import type { Element } from "@wdprlib/ast";
 import { getModuleParseAst, type ParseFunction } from "../../types";
 import type { ListPagesModuleData } from "../resolve";
+import type { ListPagesExternalData } from "../types";
+import { createListPagesPager } from "./pager";
 
 export function wrapListPagesResult(
   module: ListPagesModuleData,
   items: Element[],
   parse: ParseFunction,
+  data?: ListPagesExternalData,
 ): Element[] {
-  if (items.length === 0) {
+  if (items.length === 0 && (!data || data.pages.length === 0)) {
     return [];
   }
 
@@ -25,6 +28,8 @@ export function wrapListPagesResult(
     result.push(...appendAst.elements);
   }
 
+  if (data) result.push(...createListPagesPager(data));
+
   if (module.wrapper) {
     return [
       {

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

@@ -56,5 +56,5 @@ export function resolveListPages(
   parse: ParseFunction,
 ): Element[] {
   const items = renderListPagesItems(module, data, compiledTemplate, parse);
-  return wrapListPagesResult(module, items, parse);
+  return wrapListPagesResult(module, items, parse, data);
 }

package/src/parser/rules/block/module/listpages/types/external-data.ts

@@ -94,6 +94,19 @@ export interface SiteContext {
  */
 export interface ListPagesExternalData {
   pages: PageData[];
+  /** Matching items before offset and limit; use the same visibility filters as pages. */
   totalCount: number;
   site: SiteContext;
+  /** Filled by module resolution when a page URL is available. */
+  pagination?: {
+    currentPage: number;
+    perPage: number;
+    totalPages: number;
+    /** Actual fetch offset, including the module's starting offset. */
+    offset: number;
+    /** Total item limit after URL resolution, not the fetch batch size. */
+    limit?: number;
+    urlPath: string;
+    parameter: string;
+  };
 }

package/src/parser/rules/block/module/listpages/url-resolution/params.ts

@@ -2,12 +2,13 @@ import { URL_RESOLVABLE_FIELDS } from "./fields";
 
 /**
  * Parse URL path parameters like /offset/1/page2_limit/1.
- * Returns a map of parameter name -> value.
+ * Returns a map of parameter name -> value. Set hasPageName for a full page path;
+ * otherwise the legacy parameter-only-path heuristic is used.
  */
-export function parseUrlParams(url: string): Map<string, string> {
+export function parseUrlParams(url: string, hasPageName = false): Map<string, string> {
   const params = new Map<string, string>();
-  const parts = url.split("/").filter(Boolean);
-  const pairStart = isUrlParameter(parts[0]) ? 0 : 1;
+  const parts = url.split(/[?#]/, 1)[0]!.split("/").filter(Boolean);
+  const pairStart = !hasPageName && isUrlParameter(parts[0]) ? 0 : 1;
 
   // Skip the page name (first part), parse key/value pairs.
   for (let i = pairStart; i < parts.length - 1; i += 2) {

package/src/parser/rules/block/module/resolution/data-maps.ts

@@ -4,25 +4,97 @@ import type { ListUsersDataRequirement, ListUsersExternalData } from "../listuse
 import type { TagCloudDataRequirement, TagCloudExternalData } from "../tagcloud/types";
 import { parseUrlParams, resolveAndNormalizeQuery } from "../listpages/url-resolver";
 
+export interface ListPagesPaginationState {
+  nextUnprefixed: number;
+}
+
 export async function buildListPagesDataMap(
   dataProvider: DataProvider,
   requirements: ListPagesDataRequirement[],
   urlPath: string | undefined,
+  paginationState: ListPagesPaginationState = { nextUnprefixed: 1 },
 ): Promise<Map<number, ListPagesExternalData>> {
   const dataMap = new Map<number, ListPagesExternalData>();
-  const urlParams = parseUrlParams(urlPath ?? "");
+  const urlParams = parseUrlParams(urlPath ?? "", true);
 
   for (const req of requirements) {
     const normalizedQuery = resolveAndNormalizeQuery(req, urlParams);
-    const data = await dataProvider.fetchListPages?.(normalizedQuery, req);
+    if (!urlPath || !urlPath.startsWith("/") || urlPath.startsWith("//")) {
+      const data = await dataProvider.fetchListPages?.(normalizedQuery, req);
+      if (data) dataMap.set(req.id, data);
+      continue;
+    }
+    const ordinal = req.urlAttrPrefix ? 0 : paginationState.nextUnprefixed++;
+    const parameter = req.urlAttrPrefix
+      ? `${encodeURIComponent(req.urlAttrPrefix)}_p`
+      : ordinal === 1
+        ? "p"
+        : `p${ordinal}`;
+    const perPage = Math.min(250, positiveInteger(normalizedQuery.perPage, 20));
+    const baseOffset = positiveInteger(normalizedQuery.offset, 0);
+    const limit =
+      normalizedQuery.limit !== undefined && normalizedQuery.limit >= 0
+        ? Math.floor(normalizedQuery.limit)
+        : undefined;
+    const rawPage = urlParams.get(parameter) ?? "1";
+    let currentPage = /^\d+$/.test(rawPage) ? positiveInteger(Number(rawPage), 1) : 1;
+    currentPage = Math.min(
+      currentPage,
+      Math.floor((Number.MAX_SAFE_INTEGER - baseOffset) / perPage) + 1,
+    );
+    if (limit !== undefined)
+      currentPage = Math.min(currentPage, Math.max(1, Math.ceil(limit / perPage)));
+    const fetchPage = () => {
+      const relativeOffset = (currentPage - 1) * perPage;
+      return dataProvider.fetchListPages?.(
+        {
+          ...normalizedQuery,
+          offset: baseOffset + relativeOffset,
+          limit: Math.min(
+            perPage,
+            limit === undefined ? perPage : Math.max(0, limit - relativeOffset),
+          ),
+          perPage,
+        },
+        req,
+      );
+    };
+    let data = await fetchPage();
     if (data) {
-      dataMap.set(req.id, data);
+      const count = Math.min(Math.max(0, data.totalCount - baseOffset), limit ?? Infinity);
+      const totalPages = Math.ceil(count / perPage);
+      const lastPage = Math.max(1, totalPages);
+      if (currentPage > lastPage) {
+        currentPage = lastPage;
+        data = await fetchPage();
+      }
+      if (data)
+        dataMap.set(req.id, {
+          ...data,
+          pages: data.pages.slice(
+            0,
+            Math.min(perPage, Math.max(0, count - (currentPage - 1) * perPage)),
+          ),
+          pagination: {
+            currentPage,
+            perPage,
+            totalPages,
+            offset: baseOffset + (currentPage - 1) * perPage,
+            limit,
+            urlPath,
+            parameter,
+          },
+        });
     }
   }
 
   return dataMap;
 }
 
+function positiveInteger(value: number | undefined, fallback: number): number {
+  return value !== undefined && Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
 export async function buildListUsersDataMap(
   dataProvider: DataProvider,
   requirements: ListUsersDataRequirement[],

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

@@ -26,6 +26,8 @@ import {
 import { buildListPagesDataMap, buildListUsersDataMap, buildTagCloudDataMap } from "./data-maps";
 import { ModuleDocumentRegistry } from "./document";
 import { collectStyles, mergeCollectedStyles } from "./styles";
+import { createListPagesPager } from "../listpages/resolution/pager";
+import type { ListPagesPaginationState } from "./data-maps";
 
 export type AsyncModuleParseFunction = (source: string) => Promise<ModuleParseResult>;
 
@@ -40,6 +42,7 @@ export interface ResolveModulesWithAsyncParseOptions {
   };
   urlPath?: string;
   pageTags: string[];
+  paginationState?: ListPagesPaginationState;
 }
 
 export interface AsyncModuleResolutionResult {
@@ -73,7 +76,12 @@ export async function resolveModulesWithAsyncParse(
     registry.register(await options.parse(source));
 
   const [listPagesData, listUsersData, tagCloudData] = await Promise.all([
-    buildListPagesDataMap(dataProvider, options.requirements.listPages ?? [], options.urlPath),
+    buildListPagesDataMap(
+      dataProvider,
+      options.requirements.listPages ?? [],
+      options.urlPath,
+      options.paginationState,
+    ),
     buildListUsersDataMap(dataProvider, options.requirements.listUsers ?? []),
     buildTagCloudDataMap(dataProvider, options.requirements.tagCloud ?? []),
   ]);
@@ -175,9 +183,9 @@ async function resolveListPagesAsync(
     if (!page) continue;
     const variableContext: VariableContext = {
       page,
-      index: i + 1,
+      index: (data.pagination?.offset ?? 0) + i + 1,
       total: data.totalCount,
-      limit: module.limit,
+      limit: data.pagination ? data.pagination.limit : module.limit,
       site: data.site,
     };
     const parsed = await parse(template(variableContext));
@@ -197,6 +205,7 @@ async function resolveListPagesAsync(
   if (module["append-line"] && !module.separate) {
     result.push(...(await parse(module["append-line"])).elements);
   }
+  result.push(...createListPagesPager(data));
 
   return module.wrapper
     ? [

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;
   }

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

@@ -1,3 +1,4 @@
+import { precedingSingleNewline } from "../parsing/automatic-line-break";
 /**
  *
  * Parses the Wikidot anchor inline block syntax: `[[a]]...[[/a]]`.
@@ -10,7 +11,8 @@
  * - `[[a_ href="url"]]text[[/a]]` -- paragraph strip mode (trailing underscore)
  *
  * Paragraph strip mode (`[[a_]]`) suppresses newlines within the anchor
- * body and strips at most one trailing newline after the closing tag
+ * body and strips at most one automatic newline before the opening tag
+ * and one trailing newline after the closing tag
  * (preserving double newlines as paragraph breaks). This prevents
  * unwanted `<br>` elements when consecutive anchor blocks are placed on
  * separate lines.
@@ -98,6 +100,7 @@ export const anchorRule: InlineRule = {
         },
       ],
       consumed,
+      stripLeadingLineBreak: openResult.paragraphStrip ? precedingSingleNewline(ctx) : undefined,
     };
   },
 };

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

@@ -1,3 +1,4 @@
+import { createAutomaticLineBreak } from "../parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 
@@ -15,7 +16,7 @@ export function consumeAnchorNewline(
   let nextPos = pos + 1;
 
   if (!paragraphStrip) {
-    children.push({ element: "line-break" });
+    children.push(createAutomaticLineBreak(ctx.tokens[pos]!));
     while (ctx.tokens[nextPos]?.type === "WHITESPACE" && ctx.tokens[nextPos]?.lineStart) {
       nextPos++;
       consumed++;