@wdprlib/parser 3.1.2 → 4.0.0

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/index.ts

@@ -0,0 +1,72 @@
+/**
+ *
+ * Block rule for Wikidot single-line center alignment: `= text`.
+ *
+ * When a line begins with a single `=` followed by whitespace, the rest
+ * of the line is rendered as a centered paragraph (`<p style="text-align: center;">`).
+ *
+ * This is distinct from the `[[=]]...[[/=]]` alignment container (handled
+ * by `align.ts`), which wraps multiple block-level elements. The center
+ * rule here only affects a single line.
+ *
+ * Conditions for the rule to match:
+ * - Token must be EQUALS at the start of a line.
+ * - Must be exactly one `=` (4+ consecutive equals are a content separator,
+ *   handled by `content-separator.ts`).
+ * - Must be followed by a WHITESPACE token.
+ *
+ * The inline content is parsed until the end of line.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { parseInlineUntil } from "../../inline/utils";
+import { parseCenterOpen } from "./open";
+
+/**
+ * Block rule for single-line center alignment (`= text`).
+ *
+ * Produces a paragraph container with `style: "text-align: center;"`.
+ */
+export const centerRule: BlockRule = {
+  name: "center",
+  startTokens: ["EQUALS"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    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;
+    consumed += inlineResult.consumed;
+    pos += inlineResult.consumed;
+
+    // Consume newline
+    if (ctx.tokens[pos]?.type === "NEWLINE") {
+      consumed++;
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {
+              style: "text-align: center;",
+            },
+            elements: children,
+          },
+        },
+      ],
+      consumed,
+    };
+  },
+};

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/index.ts

@@ -0,0 +1,51 @@
+/**
+ *
+ * Block rule for Wikidot's float-clearing syntax: `~~~~`.
+ *
+ * Four or more tilde characters (`~`) at the start of a line produce a
+ * `<div style="clear: both;">` (or left/right) element. This is commonly
+ * used after floated images or divs to prevent subsequent content from
+ * wrapping alongside them.
+ *
+ * Variants:
+ * - `~~~~` (or more tildes) -- `clear: both`
+ * - `~~~~<` -- `clear: left`
+ * - `~~~~>` -- `clear: right`
+ *
+ * Three tildes (`~~~`) do NOT trigger this rule in Wikidot -- the minimum
+ * is four. The tilde count is validated at parse time even though the
+ * lexer already tokenises valid sequences, as a defensive check.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { parseClearFloatSyntax } from "./syntax";
+
+/**
+ * Block rule for the clear-float directive (`~~~~`, `~~~~<`, `~~~~>`).
+ *
+ * Produces a `clear-float` element whose data is the direction string:
+ * `"both"`, `"left"`, or `"right"`.
+ */
+export const clearFloatRule: BlockRule = {
+  name: "clear-float",
+  startTokens: ["CLEAR_FLOAT", "CLEAR_FLOAT_LEFT", "CLEAR_FLOAT_RIGHT"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const syntax = parseClearFloatSyntax(ctx);
+    if (!syntax) return { success: false };
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "clear-float",
+          data: syntax.direction,
+        },
+      ],
+      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,
+    };
+  },
+};

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

@@ -0,0 +1,95 @@
+import type { ParseContext } from "../../types";
+
+export type CollapsibleAttributes = Record<string, string>;
+
+/**
+ * Parses collapsible attributes that may be spread across multiple lines.
+ */
+export function parseMultilineAttributes(
+  ctx: ParseContext,
+  startPos: number,
+): { attrs: CollapsibleAttributes; consumed: number } {
+  const attrs: CollapsibleAttributes = {};
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "BLOCK_CLOSE" || token.type === "EOF") {
+      break;
+    }
+
+    if (token.type === "WHITESPACE" || token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    if (token.type === "TEXT" || token.type === "IDENTIFIER") {
+      let name = token.value;
+      pos++;
+      consumed++;
+
+      while (
+        ctx.tokens[pos]?.type === "TEXT" &&
+        ctx.tokens[pos]?.value === "-" &&
+        (ctx.tokens[pos + 1]?.type === "IDENTIFIER" || ctx.tokens[pos + 1]?.type === "TEXT")
+      ) {
+        name += "-";
+        pos++;
+        consumed++;
+        name += ctx.tokens[pos]?.value ?? "";
+        pos++;
+        consumed++;
+      }
+
+      const eqToken = ctx.tokens[pos];
+      if (eqToken?.type === "EQUALS") {
+        pos++;
+        consumed++;
+        const valueToken = ctx.tokens[pos];
+        if (valueToken?.type === "QUOTED_STRING") {
+          let value = valueToken.value;
+          if (value.startsWith('"') && value.endsWith('"')) {
+            value = value.slice(1, -1);
+          }
+          attrs[name] = value;
+          pos++;
+          consumed++;
+        } else if (valueToken?.type === "TEXT" || valueToken?.type === "IDENTIFIER") {
+          attrs[name] = valueToken.value;
+          pos++;
+          consumed++;
+        }
+      } else {
+        attrs[name] = "true";
+      }
+    } else {
+      break;
+    }
+  }
+
+  return { attrs, consumed };
+}
+
+export interface CollapsibleToggleVisibility {
+  showTop: boolean;
+  showBottom: boolean;
+}
+
+export function resolveToggleVisibility(
+  attrs: Record<string, string>,
+): CollapsibleToggleVisibility {
+  const hideLocation = (attrs.hideLocation ?? attrs.hidelocation ?? "top").toLowerCase();
+
+  if (hideLocation === "both") {
+    return { showTop: true, showBottom: true };
+  }
+  if (hideLocation === "bottom") {
+    return { showTop: false, showBottom: true };
+  }
+  if (hideLocation === "neither" || hideLocation === "none") {
+    return { showTop: false, showBottom: false };
+  }
+  return { showTop: true, showBottom: false };
+}

package/src/parser/rules/block/collapsible/body.ts

@@ -0,0 +1,69 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBlocksUntil } from "../utils";
+import { isCollapsibleClose } from "./tags";
+
+const EXCLUDED_BLOCKS = new Set(["collapsible"]);
+
+export function parseCollapsibleBody(
+  ctx: ParseContext,
+  startPos: number,
+  hasNewlineAfterOpen: boolean,
+): { elements: Element[]; consumed: number } {
+  if (
+    !hasNewlineAfterOpen &&
+    ctx.tokens[startPos]?.type !== "EOF" &&
+    ctx.tokens[startPos]?.type !== "BLOCK_END_OPEN"
+  ) {
+    return parseInlineCollapsibleBody(ctx, startPos);
+  }
+
+  const bodyCtx: ParseContext = { ...ctx, pos: startPos };
+  const closeCondition = (checkCtx: ParseContext): boolean => {
+    return isCollapsibleClose(checkCtx, checkCtx.pos);
+  };
+  const bodyResult = parseBlocksUntil(bodyCtx, closeCondition, {
+    excludedBlockNames: EXCLUDED_BLOCKS,
+  });
+
+  return {
+    elements: bodyResult.elements,
+    consumed: bodyResult.consumed,
+  };
+}
+
+function parseInlineCollapsibleBody(
+  ctx: ParseContext,
+  startPos: number,
+): { elements: Element[]; consumed: number } {
+  const inlineElements: Element[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF" || token.type === "NEWLINE") break;
+    if (isCollapsibleClose(ctx, pos)) break;
+    inlineElements.push({ element: "text", data: token.value });
+    pos++;
+    consumed++;
+  }
+
+  if (inlineElements.length === 0) {
+    return { elements: [], consumed };
+  }
+
+  return {
+    elements: [
+      {
+        element: "container",
+        data: {
+          type: "paragraph",
+          attributes: {},
+          elements: inlineElements,
+        },
+      },
+    ],
+    consumed,
+  };
+}