@wdprlib/parser 5.1.6 → 5.3.0

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

@@ -1,84 +1,11 @@
-/**
- *
- * Parses the Wikidot underline formatting syntax: `__text__`.
- *
- * Underline text is delimited by double underscores. Unlike most
- * inline formatting markers (bold, italic, etc.) which require the
- * closing marker on the same line, underline markers can span
- * multiple lines within the same paragraph. The closing marker
- * must appear before a paragraph break (blank line).
- *
- * Single newlines within underlined content are converted to
- * `<br />` elements, matching Wikidot's multiline underline behavior.
- *
- * If no closing `__` is found before a paragraph break, the opening
- * marker is emitted as literal text.
- *
- * Empty underline (`____`) is silently discarded by Wikidot (produces
- * no output).
- *
- * Renders as a `<u>` element in HTML.
- *
- * Produces a `"container"` AST element with `type: "underline"`.
- *
- * @module
- */
-import type { Element } from "@wdprlib/ast";
-import type { InlineRule, ParseContext, RuleResult } from "../../types";
-import { currentToken, hasClosingMarkerBeforeParagraphBreak } from "../../types";
-import { createInlineContainer } from "../formatting/container";
-import { parseUnderlineContent } from "./content";
+import type { InlineRule } from "../../types";
+import { parseDelimitedContainer } from "../formatting/container";
 
-/**
- * Inline rule for parsing `__underline__` formatting.
- *
- * Triggered by an `UNDERLINE_MARKER` token (`__`). Uses
- * {@link hasClosingMarkerBeforeParagraphBreak} instead of the
- * single-line variant because Wikidot allows underline to span
- * multiple lines within a paragraph.
- *
- * When no closing marker is found before a paragraph break, the
- * opening `__` is treated as literal text.
- */
+/** Underline can span ordinary newlines, but cannot cross its enclosing block. */
 export const underlineRule: InlineRule = {
   name: "underline",
   startTokens: ["UNDERLINE_MARKER"],
-
-  /**
-   * Attempts to parse underline formatting at the current position.
-   *
-   * @param ctx - Parse context with token stream and current position
-   * @returns A successful result containing either a `"container"` element
-   *          with `type: "underline"`, an empty array (for `____`), or a
-   *          text fallback for unmatched markers
-   */
-  parse(ctx: ParseContext): RuleResult<Element> {
-    const startToken = currentToken(ctx);
-
-    // Check if closing marker exists before paragraph break
-    if (!hasClosingMarkerBeforeParagraphBreak({ ...ctx, pos: ctx.pos + 1 }, "UNDERLINE_MARKER")) {
-      return {
-        success: true,
-        elements: [{ element: "text", data: startToken.value }],
-        consumed: 1,
-      };
-    }
-
-    const { children, consumed } = parseUnderlineContent(ctx, ctx.pos + 1);
-
-    // Empty underline (____) is discarded entirely in Wikidot
-    if (children.length === 0) {
-      return {
-        success: true,
-        elements: [],
-        consumed,
-      };
-    }
-
-    return {
-      success: true,
-      elements: [createInlineContainer("underline", children)],
-      consumed,
-    };
+  parse(ctx) {
+    return parseDelimitedContainer(ctx, "UNDERLINE_MARKER", "underline", { discardEmpty: true });
   },
 };

package/src/parser/rules/tokens.ts

@@ -1,5 +1,6 @@
 import type { Token, TokenType } from "../../lexer";
 import type { ParseContext } from "./contracts";
+import { getParagraphNewlineBoundary } from "./inline/parsing/paragraph-boundary";
 
 /**
  * Helper to get current token
@@ -51,7 +52,7 @@ export function hasClosingMarkerBeforeNewline(
   markerValue?: string,
 ): boolean {
   let pos = ctx.pos;
-  while (pos < ctx.tokens.length) {
+  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
     const token = ctx.tokens[pos];
     if (!token || token.type === "NEWLINE" || token.type === "EOF") {
       return false;
@@ -76,24 +77,14 @@ export function hasClosingMarkerBeforeParagraphBreak(
   markerValue?: string,
 ): boolean {
   let pos = ctx.pos;
-  while (pos < ctx.tokens.length) {
+  while (pos < (ctx.scope.inlineEnd ?? ctx.tokens.length)) {
     const token = ctx.tokens[pos];
     if (!token || token.type === "EOF") {
       return false;
     }
-    // Check for paragraph break (NEWLINE followed by NEWLINE after optional whitespace)
-    if (token.type === "NEWLINE") {
-      let lookAhead = 1;
-      while (ctx.tokens[pos + lookAhead]?.type === "WHITESPACE") {
-        lookAhead++;
-      }
-      if (
-        ctx.tokens[pos + lookAhead]?.type === "NEWLINE" ||
-        ctx.tokens[pos + lookAhead]?.type === "EOF" ||
-        !ctx.tokens[pos + lookAhead]
-      ) {
-        return false;
-      }
+    if (ctx.scope.blockCloseCondition?.({ ...ctx, pos })) return false;
+    if (token.type === "NEWLINE" && getParagraphNewlineBoundary(ctx, pos, true).shouldBreak) {
+      return false;
     }
     if (token.type === markerType) {
       if (markerValue === undefined || token.value === markerValue) {

package/src/pipeline/process.ts

@@ -82,6 +82,12 @@ export async function processWikitext<TPage extends WikitextPageContext>(
   const dataProvider = createModuleDataProvider(options, callbackContext);
   const parseFragment = parseSource;
   let ast = initial.ast;
+  const paginationState = { nextUnprefixed: 1 };
+  const requestedPath = options.page.urlPath;
+  const urlPath =
+    !requestedPath || /^\/(?:[?#]|$)/.test(requestedPath)
+      ? `/${options.page.fullName}${requestedPath?.slice(1) ?? ""}`
+      : requestedPath;
 
   for (let pass = 0; pass < DEFAULT_MODULE_MAX_PASSES; pass++) {
     const extraction = extractDataRequirements(ast);
@@ -94,7 +100,8 @@ export async function processWikitext<TPage extends WikitextPageContext>(
       compiledListPagesTemplates: extraction.compiledListPagesTemplates,
       compiledListUsersTemplates: extraction.compiledListUsersTemplates,
       requirements: extraction.requirements,
-      urlPath: options.page.urlPath,
+      urlPath,
+      paginationState,
       pageTags: options.page.tags,
     });
     ast = resolved.ast;

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

@@ -1,26 +0,0 @@
-import type { Element } from "@wdprlib/ast";
-import type { ParseContext } from "../../types";
-import { parseInlineUntil } from "../utils";
-
-export interface UnderlineChildResult {
-  elements: Element[];
-  consumed: number;
-}
-
-export function parseUnderlineChild(ctx: ParseContext, pos: number): UnderlineChildResult {
-  const token = ctx.tokens[pos];
-  if (!token) {
-    return { elements: [], consumed: 0 };
-  }
-
-  if (token.type === "NEWLINE") {
-    return { elements: [{ element: "line-break" }], consumed: 1 };
-  }
-
-  const result = parseInlineUntil({ ...ctx, pos }, "UNDERLINE_MARKER");
-  if (result.elements.length > 0) {
-    return { elements: result.elements, consumed: result.consumed };
-  }
-
-  return { elements: [{ element: "text", data: token.value }], consumed: 1 };
-}

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

@@ -1,29 +0,0 @@
-import type { Element } from "@wdprlib/ast";
-import type { ParseContext } from "../../types";
-import { parseUnderlineChild } from "./child";
-
-export function parseUnderlineContent(
-  ctx: ParseContext,
-  startPos: number,
-): { children: Element[]; consumed: number } {
-  const children: Element[] = [];
-  let pos = startPos;
-  let consumed = 1;
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token || token.type === "EOF") break;
-
-    if (token.type === "UNDERLINE_MARKER") {
-      consumed++;
-      break;
-    }
-
-    const child = parseUnderlineChild(ctx, pos);
-    children.push(...child.elements);
-    pos += child.consumed;
-    consumed += child.consumed;
-  }
-
-  return { children, consumed };
-}