@wdprlib/parser 3.2.0 → 4.1.0

package/src/parser/rules/block/block-list/tags.ts

@@ -0,0 +1,50 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+
+export type ListBlockType = "ul" | "ol";
+
+export function isListBlockType(name: string): name is ListBlockType {
+  return name === "ul" || name === "ol";
+}
+
+export function isListClose(ctx: ParseContext, pos: number, expectedType?: ListBlockType): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return false;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult) return false;
+  return expectedType ? nameResult.name === expectedType : isListBlockType(nameResult.name);
+}
+
+export function isLiClose(ctx: ParseContext, pos: number): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return false;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  return nameResult?.name === "li";
+}
+
+export function isLiOpen(
+  ctx: ParseContext,
+  pos: number,
+): { name: string; consumed: number } | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult || nameResult.name !== "li") return null;
+  return { name: nameResult.name, consumed: 1 + nameResult.consumed };
+}
+
+export function isNestedListOpen(
+  ctx: ParseContext,
+  pos: number,
+): { type: ListBlockType; consumed: number } | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult || !isListBlockType(nameResult.name)) return null;
+  return { type: nameResult.name, consumed: 1 + nameResult.consumed };
+}
+
+export function consumeCloseTag(ctx: ParseContext, pos: number): number {
+  let closeConsumed = 1;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (nameResult) closeConsumed += nameResult.consumed;
+  if (ctx.tokens[pos + closeConsumed]?.type === "BLOCK_CLOSE") closeConsumed++;
+  if (ctx.tokens[pos + closeConsumed]?.type === "NEWLINE") closeConsumed++;
+  return closeConsumed;
+}

package/src/parser/rules/block/blockquote/build.ts

@@ -0,0 +1,62 @@
+import type { Element } from "@wdprlib/ast";
+import { processDepths, type DepthList } from "../../../depth";
+import type { BlockquoteLine, ParsedBlockquoteLine } from "./lines";
+
+export function buildBlockquoteElements(lines: ParsedBlockquoteLine[]): Element[] {
+  const depthTrees = processDepths<null, BlockquoteLine>(null, lines);
+  return depthTrees.map(({ list }) => buildBlockquoteElement(list));
+}
+
+function buildBlockquoteElement(list: DepthList<null, BlockquoteLine>): Element {
+  const children: Element[] = [];
+  let currentParagraphChildren: Element[] = [];
+
+  function flushParagraph() {
+    if (currentParagraphChildren.length > 0) {
+      while (
+        currentParagraphChildren.length > 0 &&
+        currentParagraphChildren[currentParagraphChildren.length - 1]?.element === "line-break"
+      ) {
+        currentParagraphChildren.pop();
+      }
+      if (currentParagraphChildren.length > 0) {
+        children.push({
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {},
+            elements: currentParagraphChildren,
+          },
+        });
+      }
+      currentParagraphChildren = [];
+    }
+  }
+
+  for (const item of list) {
+    if (item.kind === "item") {
+      if (item.value.elements.length === 0) {
+        flushParagraph();
+        continue;
+      }
+      currentParagraphChildren.push(...item.value.elements);
+      if (item.value.hasLineBreak) {
+        currentParagraphChildren.push({ element: "line-break" });
+      }
+    } else {
+      flushParagraph();
+      children.push(buildBlockquoteElement(item.children));
+    }
+  }
+
+  flushParagraph();
+
+  return {
+    element: "container",
+    data: {
+      type: "blockquote",
+      attributes: {},
+      elements: children,
+    },
+  };
+}

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

@@ -0,0 +1,80 @@
+/**
+ *
+ * Block rule for Wikidot-style blockquotes using `>` markers.
+ *
+ * Wikidot blockquotes are written with one or more `>` characters at the
+ * start of a line, followed by a mandatory space and then the content:
+ *
+ * ```
+ * > First level
+ * >> Second level
+ * > Back to first
+ * ```
+ *
+ * Key behaviours:
+ * - The depth is determined by the number of consecutive `>` characters.
+ * - A space after the `>` markers is required; lines like `>No space` are
+ *   consumed but silently discarded from output.
+ * - An empty line (just `> `) within the same depth acts as a paragraph
+ *   separator inside the blockquote.
+ * - Nesting is handled by the generic {@link processDepths} utility, which
+ *   converts flat depth-annotated rows into a recursive tree structure.
+ * - Maximum depth is capped at `MAX_BLOCKQUOTE_DEPTH` (30) to guard
+ *   against pathological input.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { buildBlockquoteElements, collectBlockquoteLines } from "./lines";
+
+/**
+ * Block rule for `>` prefix blockquotes.
+ *
+ * Parsing strategy:
+ * 1. Collect consecutive lines that begin with BLOCKQUOTE_MARKER at line start.
+ * 2. For each line, record the depth (number of `>` chars, zero-indexed)
+ *    and parse the inline content after the mandatory space.
+ * 3. Lines missing the required space are consumed but produce no output.
+ * 4. Feed the flat depth list into {@link processDepths} to build a nested tree.
+ * 5. Recursively convert the tree into nested blockquote container elements
+ *    via `buildBlockquoteElement()`.
+ */
+export const blockquoteRule: BlockRule = {
+  name: "blockquote",
+  startTokens: ["BLOCKQUOTE_MARKER"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const firstToken = currentToken(ctx);
+
+    if (!firstToken.lineStart) {
+      return { success: false };
+    }
+
+    const blockquoteLines = collectBlockquoteLines(ctx);
+
+    // No rows parsed
+    if (blockquoteLines.lines.length === 0) {
+      // If we consumed tokens (e.g. lines without space after >), return empty success
+      if (blockquoteLines.consumed > 0) {
+        return { success: true, elements: [], consumed: blockquoteLines.consumed };
+      }
+      return { success: false };
+    }
+
+    const blockquotes = buildBlockquoteElements(blockquoteLines.lines);
+
+    // Return first blockquote (should usually be only one)
+    if (blockquotes.length === 0) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: blockquotes,
+      consumed: blockquoteLines.consumed,
+    };
+  },
+};

package/src/parser/rules/block/blockquote/line.ts

@@ -0,0 +1,79 @@
+import type { ParseContext } from "../../types";
+import { parseInlineUntil } from "../../inline/utils";
+import type { ParsedBlockquoteLine } from "./lines";
+
+/**
+ * Safety limit for blockquote nesting depth.
+ * Lines exceeding this depth are not parsed, preventing stack issues
+ * on deeply nested or malicious input.
+ */
+const MAX_BLOCKQUOTE_DEPTH = 30;
+
+export type BlockquoteLineParseResult =
+  | { kind: "parsed"; line: ParsedBlockquoteLine; consumed: number }
+  | { kind: "skipped"; consumed: number }
+  | { kind: "stop" };
+
+export function parseBlockquoteLine(
+  ctx: ParseContext,
+  startPos: number,
+): BlockquoteLineParseResult {
+  const markerToken = ctx.tokens[startPos];
+  if (!markerToken || !markerToken.lineStart || markerToken.type !== "BLOCKQUOTE_MARKER") {
+    return { kind: "stop" };
+  }
+
+  const depth = markerToken.value.length;
+  if (depth > MAX_BLOCKQUOTE_DEPTH) {
+    return { kind: "stop" };
+  }
+
+  let pos = startPos + 1;
+  let consumed = 1;
+
+  if (ctx.tokens[pos]?.type !== "WHITESPACE") {
+    return { kind: "skipped", consumed: consumeLineRemainder(ctx, pos) + consumed };
+  }
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const inlineCtx: ParseContext = { ...ctx, pos };
+  const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
+  consumed += inlineResult.consumed;
+  pos += inlineResult.consumed;
+
+  let hasLineBreak = false;
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    hasLineBreak = true;
+    consumed++;
+  }
+
+  return {
+    kind: "parsed",
+    line: {
+      depth: depth - 1,
+      ltype: null,
+      value: { elements: inlineResult.elements, hasLineBreak },
+    },
+    consumed,
+  };
+}
+
+function consumeLineRemainder(ctx: ParseContext, startPos: number): number {
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length && ctx.tokens[pos]?.type !== "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return consumed;
+}

package/src/parser/rules/block/blockquote/lines.ts

@@ -0,0 +1,39 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBlockquoteLine } from "./line";
+export { buildBlockquoteElements } from "./build";
+
+export interface BlockquoteLine {
+  elements: Element[];
+  hasLineBreak: boolean;
+}
+
+export interface ParsedBlockquoteLine {
+  depth: number;
+  ltype: null;
+  value: BlockquoteLine;
+}
+
+export interface ParsedBlockquoteLines {
+  lines: ParsedBlockquoteLine[];
+  consumed: number;
+}
+
+export function collectBlockquoteLines(ctx: ParseContext): ParsedBlockquoteLines {
+  const lines: ParsedBlockquoteLine[] = [];
+  let pos = ctx.pos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const result = parseBlockquoteLine(ctx, pos);
+    if (result.kind === "stop") break;
+
+    pos += result.consumed;
+    consumed += result.consumed;
+    if (result.kind === "parsed") {
+      lines.push(result.line);
+    }
+  }
+
+  return { lines, consumed };
+}

package/src/parser/rules/block/{center.ts → center/index.ts}

@@ -20,9 +20,9 @@
  * @module
  */
 import type { Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseInlineUntil } from "../inline/utils";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { parseInlineUntil } from "../../inline/utils";
+import { parseCenterOpen } from "./open";
 
 /**
  * Block rule for single-line center alignment (`= text`).
@@ -35,27 +35,12 @@ export const centerRule: BlockRule = {
   requiresLineStart: true,
 
   parse(ctx: ParseContext): RuleResult<Element> {
-    const marker = currentToken(ctx);
-
-    if (!marker.lineStart) {
-      return { success: false };
-    }
-
-    // Wikidot requires whitespace after = for center alignment
-    let pos = ctx.pos + 1;
-    let consumed = 1;
-
-    if (ctx.tokens[pos]?.type !== "WHITESPACE") {
-      return { success: false };
-    }
-
-    // Skip whitespace
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
+    const openResult = parseCenterOpen(ctx);
+    if (!openResult) return { success: false };
 
     // Parse inline content until newline
+    let pos = openResult.bodyStart;
+    let consumed = openResult.consumed;
     const inlineCtx: ParseContext = { ...ctx, pos };
     const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
     const children: Element[] = inlineResult.elements;

package/src/parser/rules/block/center/open.ts

@@ -0,0 +1,27 @@
+import type { ParseContext } from "../../types";
+
+export interface CenterOpenResult {
+  bodyStart: number;
+  consumed: number;
+}
+
+export function parseCenterOpen(ctx: ParseContext): CenterOpenResult | null {
+  const marker = ctx.tokens[ctx.pos];
+  if (marker?.type !== "EQUALS" || !marker.lineStart) {
+    return null;
+  }
+
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+
+  if (ctx.tokens[pos]?.type !== "WHITESPACE") {
+    return null;
+  }
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  return { bodyStart: pos, consumed };
+}

package/src/parser/rules/block/{clear-float.ts → clear-float/index.ts}

@@ -19,8 +19,8 @@
  * @module
  */
 import type { Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { parseClearFloatSyntax } from "./syntax";
 
 /**
  * Block rule for the clear-float directive (`~~~~`, `~~~~<`, `~~~~>`).
@@ -34,42 +34,18 @@ export const clearFloatRule: BlockRule = {
   requiresLineStart: true,
 
   parse(ctx: ParseContext): RuleResult<Element> {
-    const token = currentToken(ctx);
-
-    if (!token.lineStart) {
-      return { success: false };
-    }
-
-    // Count tildes - Wikidot requires at least 4
-    const tildeCount = token.value.replace(/[<>]$/, "").length;
-    if (tildeCount < 4) {
-      return { success: false };
-    }
-
-    // Determine direction
-    let direction: "both" | "left" | "right" = "both";
-    if (token.type === "CLEAR_FLOAT_LEFT") {
-      direction = "left";
-    } else if (token.type === "CLEAR_FLOAT_RIGHT") {
-      direction = "right";
-    }
-
-    let consumed = 1;
-
-    // Consume newline if present
-    if (ctx.tokens[ctx.pos + 1]?.type === "NEWLINE") {
-      consumed++;
-    }
+    const syntax = parseClearFloatSyntax(ctx);
+    if (!syntax) return { success: false };
 
     return {
       success: true,
       elements: [
         {
           element: "clear-float",
-          data: direction,
+          data: syntax.direction,
         },
       ],
-      consumed,
+      consumed: syntax.consumed,
     };
   },
 };

package/src/parser/rules/block/clear-float/syntax.ts

@@ -0,0 +1,43 @@
+import type { ParseContext } from "../../types";
+
+type ClearFloatDirection = "both" | "left" | "right";
+
+export interface ClearFloatSyntax {
+  direction: ClearFloatDirection;
+  consumed: number;
+}
+
+export function parseClearFloatSyntax(ctx: ParseContext): ClearFloatSyntax | null {
+  const token = ctx.tokens[ctx.pos];
+  if (
+    !token ||
+    !token.lineStart ||
+    (token.type !== "CLEAR_FLOAT" &&
+      token.type !== "CLEAR_FLOAT_LEFT" &&
+      token.type !== "CLEAR_FLOAT_RIGHT")
+  ) {
+    return null;
+  }
+
+  const tildeCount = token.value.replace(/[<>]$/, "").length;
+  if (tildeCount < 4) {
+    return null;
+  }
+
+  return {
+    direction: clearFloatDirection(token.type),
+    consumed: 1 + (ctx.tokens[ctx.pos + 1]?.type === "NEWLINE" ? 1 : 0),
+  };
+}
+
+function clearFloatDirection(
+  tokenType: "CLEAR_FLOAT" | "CLEAR_FLOAT_LEFT" | "CLEAR_FLOAT_RIGHT",
+): ClearFloatDirection {
+  if (tokenType === "CLEAR_FLOAT_LEFT") {
+    return "left";
+  }
+  if (tokenType === "CLEAR_FLOAT_RIGHT") {
+    return "right";
+  }
+  return "both";
+}

package/src/parser/rules/block/code/attributes.ts

@@ -0,0 +1,30 @@
+import type { ParseContext } from "../../types";
+
+export function repairSwallowedCodeClose(
+  ctx: ParseContext,
+  pos: number,
+  attrs: Record<string, string>,
+): { closingSwallowed: boolean } | null {
+  const prevToken = ctx.tokens[pos - 1];
+  if (prevToken?.type !== "QUOTED_STRING" || !prevToken.value.includes("]]")) {
+    return null;
+  }
+
+  const rawValue = prevToken.value;
+  const bracketIdx = rawValue.indexOf("]]");
+  const truncatedValue = rawValue.startsWith('"')
+    ? rawValue.slice(1, bracketIdx)
+    : rawValue.slice(0, bracketIdx);
+
+  for (const key of Object.keys(attrs)) {
+    const stored = attrs[key]!;
+    if (stored === rawValue || stored === rawValue.slice(1, -1) || stored === rawValue.slice(1)) {
+      attrs[key] = truncatedValue;
+      break;
+    }
+  }
+
+  return {
+    closingSwallowed: rawValue.includes("[[/code]]"),
+  };
+}

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

@@ -0,0 +1,57 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+
+export interface CodeContentResult {
+  contents: string;
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function collectCodeContent(
+  ctx: ParseContext,
+  startPos: number,
+  closingSwallowed: boolean,
+): CodeContentResult {
+  const contentParts: string[] = [];
+  let pos = startPos;
+  let consumed = 0;
+  let foundClose = closingSwallowed;
+
+  while (!closingSwallowed && pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    if (token.type === "BLOCK_END_OPEN") {
+      const closeNameResult = parseBlockName(ctx, pos + 1);
+      if (closeNameResult?.name === "code") {
+        foundClose = true;
+        const closeConsumed = consumeCodeClose(ctx, pos, closeNameResult.consumed);
+        consumed += closeConsumed;
+        break;
+      }
+    }
+
+    contentParts.push(token.value);
+    pos++;
+    consumed++;
+  }
+
+  return { contents: contentParts.join(""), consumed, foundClose };
+}
+
+function consumeCodeClose(ctx: ParseContext, startPos: number, closeNameConsumed: number): number {
+  let pos = startPos + 1 + closeNameConsumed;
+  let consumed = 1 + closeNameConsumed;
+
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    pos++;
+    consumed++;
+  }
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return consumed;
+}

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

@@ -0,0 +1,100 @@
+/**
+ *
+ * Block rule for the Wikidot code block: `[[code]]...[[/code]]`.
+ *
+ * A code block captures its body as raw text (no inline parsing) and
+ * supports two optional attributes:
+ * - `type` -- the programming language for syntax highlighting.
+ * - `name` -- a label or filename displayed alongside the code.
+ *
+ * @module
+ */
+import type { Element, CodeBlockData } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseBlockName } from "../utils";
+import { parseAttributesRaw } from "../utils";
+import { repairSwallowedCodeClose } from "./attributes";
+import { collectCodeContent } from "./content";
+
+/**
+ * Block rule for `[[code type="..." name="..."]]...[[/code]]`.
+ *
+ * Body content is stored as-is (not parsed for inline markup). The rule
+ * also registers the code block in `ctx.codeBlocks` for document-level
+ * introspection.
+ */
+export const codeBlockRule: BlockRule = {
+  name: "code",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    let pos = ctx.pos + 1;
+    let consumed = 1;
+
+    const nameResult = parseBlockName(ctx, pos);
+    if (!nameResult || nameResult.name !== "code") {
+      return { success: false };
+    }
+
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
+
+    const attrResult = parseAttributesRaw(ctx, pos);
+    pos += attrResult.consumed;
+    consumed += attrResult.consumed;
+
+    let closingSwallowed = false;
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      const repaired = repairSwallowedCodeClose(ctx, pos, attrResult.attrs);
+      if (!repaired) return { success: false };
+      closingSwallowed = repaired.closingSwallowed;
+    } else {
+      pos++;
+      consumed++;
+    }
+
+    if (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+
+    const contentResult = collectCodeContent(ctx, pos, closingSwallowed);
+    let codeContent = contentResult.contents.replace(/\n$/, "");
+    consumed += contentResult.consumed;
+    pos += contentResult.consumed;
+
+    if (!contentResult.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/code]] for [[code]]",
+        position: openToken.position,
+      });
+    }
+
+    const codeBlockData: CodeBlockData = {
+      contents: codeContent,
+      language: attrResult.attrs.type ?? null,
+      name: attrResult.attrs.name ?? null,
+    };
+    ctx.codeBlocks.push(codeBlockData);
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "code",
+          data: codeBlockData,
+        },
+      ],
+      consumed,
+    };
+  },
+};