@wdprlib/parser 3.2.0 → 4.0.0

package/src/parser/rules/inline/line-break/newline.ts

@@ -0,0 +1,82 @@
+import type { Element } from "@wdprlib/ast";
+import type { TokenType } from "../../../../lexer";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+
+export const newlineLineBreakRule: InlineRule = {
+  name: "newlineLineBreak",
+  startTokens: ["NEWLINE"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const currentTok = ctx.tokens[ctx.pos];
+    if (!currentTok || currentTok.type !== "NEWLINE") {
+      return { success: false };
+    }
+
+    const lookAhead = skipWhitespace(ctx, ctx.pos + 1) - ctx.pos;
+    const nextMeaningfulToken = ctx.tokens[ctx.pos + lookAhead];
+    const suppressLineBreak =
+      !nextMeaningfulToken ||
+      nextMeaningfulToken.type === "EOF" ||
+      nextMeaningfulToken.type === "NEWLINE" ||
+      isValidBlockStartAfterNewline(ctx, ctx.pos + lookAhead) ||
+      hasBackslashBreakAfterNewline(ctx);
+
+    if (suppressLineBreak) {
+      return { success: true, elements: [], consumed: 1 };
+    }
+
+    return {
+      success: true,
+      elements: [{ element: "line-break" }],
+      consumed: 1,
+    };
+  },
+};
+
+function isBlockStartToken(type: TokenType | undefined): boolean {
+  switch (type) {
+    case "BLOCKQUOTE_MARKER":
+    case "LIST_BULLET":
+    case "LIST_NUMBER":
+    case "HEADING_MARKER":
+    case "HR_MARKER":
+    case "TABLE_MARKER":
+      return true;
+    default:
+      return false;
+  }
+}
+
+function isValidBlockStartAfterNewline(ctx: ParseContext, tokenPos: number): boolean {
+  const token = ctx.tokens[tokenPos];
+  if (!isBlockStartToken(token?.type) || !token?.lineStart) {
+    return false;
+  }
+
+  if (token.type !== "HEADING_MARKER") {
+    return true;
+  }
+
+  const markerLen = token.value.length;
+  const afterMarker = ctx.tokens[tokenPos + 1];
+  if (markerLen > 6) {
+    return false;
+  }
+  if (afterMarker?.type === "STAR") {
+    return ctx.tokens[tokenPos + 2]?.type === "WHITESPACE";
+  }
+  return afterMarker?.type === "WHITESPACE";
+}
+
+function hasBackslashBreakAfterNewline(ctx: ParseContext): boolean {
+  const nextPos = skipWhitespace(ctx, ctx.pos + 1);
+  return ctx.tokens[nextPos]?.type === "BACKSLASH_BREAK";
+}
+
+function skipWhitespace(ctx: ParseContext, startPos: number): number {
+  let pos = startPos;
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+  }
+  return pos;
+}

package/src/parser/rules/inline/line-break/underscore.ts

@@ -0,0 +1,45 @@
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { createPreservedLineBreak } from "./elements";
+
+export const underscoreLineBreakRule: InlineRule = {
+  name: "underscoreLineBreak",
+  startTokens: ["WHITESPACE", "UNDERSCORE"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const currentTok = ctx.tokens[ctx.pos];
+    if (!currentTok) {
+      return { success: false };
+    }
+
+    if (currentTok.type === "WHITESPACE") {
+      const nextTok = ctx.tokens[ctx.pos + 1];
+      const afterTok = ctx.tokens[ctx.pos + 2];
+
+      if (
+        nextTok?.type === "UNDERSCORE" &&
+        afterTok &&
+        (afterTok.type === "NEWLINE" || afterTok.type === "EOF")
+      ) {
+        return {
+          success: true,
+          elements: [createPreservedLineBreak()],
+          consumed: 3,
+        };
+      }
+    }
+
+    if (currentTok.type === "UNDERSCORE" && currentTok.lineStart) {
+      const nextTok = ctx.tokens[ctx.pos + 1];
+      if (nextTok && (nextTok.type === "NEWLINE" || nextTok.type === "EOF")) {
+        return {
+          success: true,
+          elements: [createPreservedLineBreak()],
+          consumed: 2,
+        };
+      }
+    }
+
+    return { success: false };
+  },
+};

package/src/parser/rules/inline/link-anchor.ts

@@ -22,7 +22,7 @@
  */
 import type { Element, LinkLabel } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { hasClosingMarkerBeforeNewline } from "../types";
+import { parseAnchorBracketLink } from "./link-bracket/parsed";
 
 /**
  * Inline rule for parsing `[#anchor Label]` anchor links.
@@ -47,72 +47,10 @@ export const linkAnchorRule: InlineRule = {
    *          or `{ success: false }`
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    // Check if closing bracket exists
-    if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "BRACKET_CLOSE")) {
-      return { success: false };
-    }
+    const parsed = parseAnchorBracketLink(ctx);
+    if (!parsed) return { success: false };
 
-    let pos = ctx.pos + 1;
-    let consumed = 1; // [#
-
-    // Collect anchor name (until whitespace)
-    let anchor = "";
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (
-        !token ||
-        token.type === "WHITESPACE" ||
-        token.type === "BRACKET_CLOSE" ||
-        token.type === "NEWLINE" ||
-        token.type === "EOF"
-      ) {
-        break;
-      }
-      anchor += token.value;
-      pos++;
-      consumed++;
-    }
-
-    // Skip whitespace between anchor and label
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-
-    // Collect label (until closing bracket)
-    let label = "";
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (
-        !token ||
-        token.type === "BRACKET_CLOSE" ||
-        token.type === "NEWLINE" ||
-        token.type === "EOF"
-      ) {
-        break;
-      }
-      label += token.value;
-      pos++;
-      consumed++;
-    }
-
-    // Consume closing bracket
-    if (ctx.tokens[pos]?.type === "BRACKET_CLOSE") {
-      pos++;
-      consumed++;
-    } else {
-      return { success: false };
-    }
-
-    const trimmedLabel = label.trim();
-    if (!trimmedLabel) {
-      return { success: false };
-    }
-
-    // Determine target: if anchor is empty, use javascript:; (fake link)
-    // Otherwise, normalize and prepend #
-    const target = anchor.trim() ? `#${normalizeAnchor(anchor.trim())}` : "javascript:;";
-    const linkLabel: LinkLabel = { text: trimmedLabel };
+    const linkLabel: LinkLabel = { text: parsed.labelText };
 
     return {
       success: true,
@@ -121,27 +59,14 @@ export const linkAnchorRule: InlineRule = {
           element: "link",
           data: {
             type: "anchor",
-            link: target,
+            link: parsed.link,
             extra: null,
             label: linkLabel,
             target: null,
           },
         },
       ],
-      consumed,
+      consumed: parsed.consumed,
     };
   },
 };
-
-/**
- * Normalizes an anchor name for use in a URL fragment.
- *
- * Converts to lowercase and replaces whitespace sequences with single
- * hyphens, matching Wikidot's anchor normalization behavior.
- *
- * @param anchor - The raw anchor name from the markup
- * @returns The normalized anchor name suitable for a URL fragment
- */
-function normalizeAnchor(anchor: string): string {
-  return anchor.toLowerCase().replace(/\s+/g, "-");
-}

package/src/parser/rules/inline/link-bracket/anchor.ts

@@ -0,0 +1,3 @@
+export function normalizeAnchor(anchor: string): string {
+  return anchor.toLowerCase().replace(/\s+/g, "-");
+}

package/src/parser/rules/inline/link-bracket/direct-url.ts

@@ -0,0 +1,5 @@
+export function isDirectBracketUrl(url: string): boolean {
+  return (
+    url !== "" && (url.startsWith("/") || url.startsWith("http://") || url.startsWith("https://"))
+  );
+}

package/src/parser/rules/inline/link-bracket/parsed.ts

@@ -0,0 +1,81 @@
+import type { AnchorTarget } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { normalizeAnchor } from "./anchor";
+import { isDirectBracketUrl } from "./direct-url";
+import { collectBracketLinkParts } from "./parts";
+import { parseBracketLinkPrefix } from "./prefix";
+
+export interface ParsedBracketLink {
+  link: string;
+  labelText: string;
+  target: AnchorTarget | null;
+  consumed: number;
+}
+
+export function parseSingleBracketLink(ctx: ParseContext): ParsedBracketLink | null {
+  const prefix = parseBracketLinkPrefix(ctx, ctx.pos + 1);
+  const parts = collectBracketLinkParts(ctx, prefix.bodyStart);
+  if (!parts) {
+    return null;
+  }
+
+  const link = parts.first.trim();
+  if (!isDirectBracketUrl(link)) {
+    return null;
+  }
+
+  const labelText = parts.label.trim();
+  if (!labelText) {
+    return null;
+  }
+
+  return {
+    link,
+    labelText,
+    target: prefix.target,
+    consumed: 1 + prefix.consumed + parts.consumed,
+  };
+}
+
+export function parseStarBracketLink(ctx: ParseContext): ParsedBracketLink | null {
+  const parts = collectBracketLinkParts(ctx, ctx.pos + 1);
+  if (!parts) {
+    return null;
+  }
+
+  const link = parts.first.trim();
+  if (!link) {
+    return null;
+  }
+
+  const labelText = parts.label.trim() || link;
+
+  return {
+    link,
+    labelText,
+    target: "new-tab",
+    consumed: 1 + parts.consumed,
+  };
+}
+
+export function parseAnchorBracketLink(
+  ctx: ParseContext,
+): Omit<ParsedBracketLink, "target"> | null {
+  const parts = collectBracketLinkParts(ctx, ctx.pos + 1);
+  if (!parts) {
+    return null;
+  }
+
+  const labelText = parts.label.trim();
+  if (!labelText) {
+    return null;
+  }
+
+  const anchor = parts.first.trim();
+
+  return {
+    link: anchor ? `#${normalizeAnchor(anchor)}` : "javascript:;",
+    labelText,
+    consumed: 1 + parts.consumed,
+  };
+}

package/src/parser/rules/inline/link-bracket/parts.ts

@@ -0,0 +1,64 @@
+import type { ParseContext } from "../../types";
+import { hasClosingMarkerBeforeNewline } from "../../types";
+
+export interface BracketLinkParts {
+  first: string;
+  label: string;
+  consumed: number;
+}
+
+export function collectBracketLinkParts(
+  ctx: ParseContext,
+  startPos: number,
+): BracketLinkParts | null {
+  if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: startPos }, "BRACKET_CLOSE")) {
+    return null;
+  }
+
+  let pos = startPos;
+  let consumed = 0;
+  let first = "";
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "WHITESPACE" ||
+      token.type === "BRACKET_CLOSE" ||
+      token.type === "NEWLINE" ||
+      token.type === "EOF"
+    ) {
+      break;
+    }
+    first += token.value;
+    pos++;
+    consumed++;
+  }
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  let label = "";
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "BRACKET_CLOSE" ||
+      token.type === "NEWLINE" ||
+      token.type === "EOF"
+    ) {
+      break;
+    }
+    label += token.value;
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type !== "BRACKET_CLOSE") {
+    return null;
+  }
+
+  return { first, label, consumed: consumed + 1 };
+}

package/src/parser/rules/inline/link-bracket/prefix.ts

@@ -0,0 +1,15 @@
+import type { ParseContext } from "../../types";
+
+export interface BracketLinkPrefix {
+  target: "new-tab" | null;
+  bodyStart: number;
+  consumed: number;
+}
+
+export function parseBracketLinkPrefix(ctx: ParseContext, startPos: number): BracketLinkPrefix {
+  if (ctx.tokens[startPos]?.type === "STAR") {
+    return { target: "new-tab", bodyStart: startPos + 1, consumed: 1 };
+  }
+
+  return { target: null, bodyStart: startPos, consumed: 0 };
+}

package/src/parser/rules/inline/link-single.ts

@@ -22,7 +22,7 @@
  */
 import type { Element, LinkLabel } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { hasClosingMarkerBeforeNewline } from "../types";
+import { parseSingleBracketLink } from "./link-bracket/parsed";
 
 /**
  * Inline rule for parsing `[url label]` single-bracket links.
@@ -48,84 +48,10 @@ export const linkSingleRule: InlineRule = {
    *          or `{ success: false }`
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    // Check if closing bracket exists
-    if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "BRACKET_CLOSE")) {
-      return { success: false };
-    }
+    const parsed = parseSingleBracketLink(ctx);
+    if (!parsed) return { success: false };
 
-    let pos = ctx.pos + 1;
-    let consumed = 1;
-
-    // Check for new tab marker (*)
-    let newTab = false;
-    if (ctx.tokens[pos]?.type === "STAR") {
-      newTab = true;
-      pos++;
-      consumed++;
-    }
-
-    // Collect URL (until whitespace)
-    let url = "";
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (
-        !token ||
-        token.type === "WHITESPACE" ||
-        token.type === "BRACKET_CLOSE" ||
-        token.type === "NEWLINE" ||
-        token.type === "EOF"
-      ) {
-        break;
-      }
-      url += token.value;
-      pos++;
-      consumed++;
-    }
-
-    // URL must be valid (starts with http://, https://, or /)
-    const trimmedUrl = url.trim();
-    if (!isValidUrl(trimmedUrl)) {
-      return { success: false };
-    }
-
-    // Skip whitespace between URL and label
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-
-    // Collect label (until closing bracket)
-    let label = "";
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (
-        !token ||
-        token.type === "BRACKET_CLOSE" ||
-        token.type === "NEWLINE" ||
-        token.type === "EOF"
-      ) {
-        break;
-      }
-      label += token.value;
-      pos++;
-      consumed++;
-    }
-
-    // Consume closing bracket
-    if (ctx.tokens[pos]?.type === "BRACKET_CLOSE") {
-      pos++;
-      consumed++;
-    } else {
-      // No closing bracket found
-      return { success: false };
-    }
-
-    const trimmedLabel = label.trim();
-    if (!trimmedLabel) {
-      return { success: false };
-    }
-
-    const linkLabel: LinkLabel = { text: trimmedLabel };
+    const linkLabel: LinkLabel = { text: parsed.labelText };
 
     return {
       success: true,
@@ -134,31 +60,14 @@ export const linkSingleRule: InlineRule = {
           element: "link",
           data: {
             type: "direct",
-            link: trimmedUrl,
+            link: parsed.link,
             extra: null,
             label: linkLabel,
-            target: newTab ? "new-tab" : null,
+            target: parsed.target,
           },
         },
       ],
-      consumed,
+      consumed: parsed.consumed,
     };
   },
 };
-
-/**
- * Validates whether a URL is acceptable for single-bracket links.
- *
- * Only absolute HTTP(S) URLs and site-relative paths (starting with `/`)
- * are accepted. Page names, interwiki prefixes, and other formats require
- * triple-bracket syntax instead.
- *
- * @param url - The trimmed URL string to validate
- * @returns `true` if the URL starts with `http://`, `https://`, or `/`
- */
-function isValidUrl(url: string): boolean {
-  if (!url) return false;
-  if (url.startsWith("/")) return true;
-  if (url.startsWith("http://") || url.startsWith("https://")) return true;
-  return false;
-}

package/src/parser/rules/inline/link-star.ts

@@ -23,7 +23,7 @@
  */
 import type { Element, LinkLabel } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { hasClosingMarkerBeforeNewline } from "../types";
+import { parseStarBracketLink } from "./link-bracket/parsed";
 
 /**
  * Inline rule for parsing `[*url label]` star links.
@@ -47,72 +47,10 @@ export const linkStarRule: InlineRule = {
    * @returns A successful result with a `"link"` element, or `{ success: false }`
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    // Check if closing bracket exists
-    if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "BRACKET_CLOSE")) {
-      return { success: false };
-    }
+    const parsed = parseStarBracketLink(ctx);
+    if (!parsed) return { success: false };
 
-    let pos = ctx.pos + 1;
-    let consumed = 1; // [*
-
-    // Collect URL (until whitespace)
-    let url = "";
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (
-        !token ||
-        token.type === "WHITESPACE" ||
-        token.type === "BRACKET_CLOSE" ||
-        token.type === "NEWLINE" ||
-        token.type === "EOF"
-      ) {
-        break;
-      }
-      url += token.value;
-      pos++;
-      consumed++;
-    }
-
-    const trimmedUrl = url.trim();
-    if (!trimmedUrl) {
-      return { success: false };
-    }
-
-    // Skip whitespace between URL and label
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-
-    // Collect label (until closing bracket)
-    let label = "";
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (
-        !token ||
-        token.type === "BRACKET_CLOSE" ||
-        token.type === "NEWLINE" ||
-        token.type === "EOF"
-      ) {
-        break;
-      }
-      label += token.value;
-      pos++;
-      consumed++;
-    }
-
-    // Consume closing bracket
-    if (ctx.tokens[pos]?.type === "BRACKET_CLOSE") {
-      pos++;
-      consumed++;
-    } else {
-      return { success: false };
-    }
-
-    const trimmedLabel = label.trim();
-    // If no label, use URL as label
-    const displayLabel = trimmedLabel || trimmedUrl;
-    const linkLabel: LinkLabel = { text: displayLabel };
+    const linkLabel: LinkLabel = { text: parsed.labelText };
 
     return {
       success: true,
@@ -121,14 +59,14 @@ export const linkStarRule: InlineRule = {
           element: "link",
           data: {
             type: "direct",
-            link: trimmedUrl,
+            link: parsed.link,
             extra: null,
             label: linkLabel,
-            target: "new-tab",
+            target: parsed.target,
           },
         },
       ],
-      consumed,
+      consumed: parsed.consumed,
     };
   },
 };

package/src/parser/rules/inline/link-triple/fallback.ts

@@ -0,0 +1,10 @@
+import type { Element } from "@wdprlib/ast";
+import type { RuleResult } from "../../types";
+
+export function literalOpenLink(value: string): RuleResult<Element> {
+  return {
+    success: true,
+    elements: [{ element: "text", data: value }],
+    consumed: 1,
+  };
+}