@wdprlib/parser 3.2.0 → 4.1.0

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

@@ -21,9 +21,11 @@
  * @module
  */
 import type { Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseBlockName, parseBlocksUntil } from "./utils";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseBlockName } from "../utils";
+import { collectIftagsCondition } from "./condition";
+import { consumeIftagsClose, isIftagsClose, parseIftagsBody } from "./body";
 
 /**
  * Block rule for `[[iftags condition]]...[[/iftags]]`.
@@ -45,7 +47,6 @@ export const iftagsRule: BlockRule = {
     let pos = ctx.pos + 1;
     let consumed = 1;
 
-    // Parse block name
     const nameResult = parseBlockName(ctx, pos);
     if (!nameResult || nameResult.name.toLowerCase() !== "iftags") {
       return { success: false };
@@ -53,93 +54,50 @@ export const iftagsRule: BlockRule = {
     pos += nameResult.consumed;
     consumed += nameResult.consumed;
 
-    // Skip whitespace
     while (ctx.tokens[pos]?.type === "WHITESPACE") {
       pos++;
       consumed++;
     }
 
-    // Parse condition (tag expressions)
-    let condition = "";
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (!token || token.type === "BLOCK_CLOSE" || token.type === "NEWLINE") {
-        break;
-      }
-      condition += token.value;
-      pos++;
-      consumed++;
-    }
+    const conditionResult = collectIftagsCondition(ctx, pos);
+    pos += conditionResult.consumed;
+    consumed += conditionResult.consumed;
 
-    // Expect ]]
     if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
       return { success: false };
     }
     pos++;
     consumed++;
 
-    // Skip newline after opening tag
     if (ctx.tokens[pos]?.type === "NEWLINE") {
       pos++;
       consumed++;
     }
 
-    // Close condition for [[/iftags]]
-    const closeCondition = (checkCtx: ParseContext): boolean => {
-      const token = checkCtx.tokens[checkCtx.pos];
-      if (token?.type === "BLOCK_END_OPEN") {
-        const closeNameResult = parseBlockName(checkCtx, checkCtx.pos + 1);
-        if (closeNameResult?.name.toLowerCase() === "iftags") {
-          return true;
-        }
-      }
-      return false;
-    };
-
-    // Parse body
-    const bodyCtx: ParseContext = { ...ctx, pos };
-    const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
-    consumed += bodyResult.consumed;
+    const bodyResult = parseIftagsBody(ctx, pos);
     pos += bodyResult.consumed;
+    consumed += bodyResult.consumed;
 
-    // Check for missing close tag
-    if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    if (!isIftagsClose(ctx, pos)) {
       ctx.diagnostics.push({
         severity: "warning",
         code: "unclosed-block",
         message: "Missing closing tag [[/iftags]] for [[iftags]]",
         position: openToken.position,
       });
+    } else {
+      const closeConsumed = consumeIftagsClose(ctx, pos);
+      pos += closeConsumed;
+      consumed += closeConsumed;
     }
 
-    // Consume [[/iftags]]
-    if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
-      pos++;
-      consumed++;
-      const closeNameResult = parseBlockName(ctx, pos);
-      if (closeNameResult) {
-        pos += closeNameResult.consumed;
-        consumed += closeNameResult.consumed;
-      }
-      if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
-        pos++;
-        consumed++;
-      }
-      if (ctx.tokens[pos]?.type === "NEWLINE") {
-        pos++;
-        consumed++;
-      }
-    }
-
-    condition = condition.trim();
-
     return {
       success: true,
       elements: [
         {
           element: "if-tags",
           data: {
-            condition,
+            condition: conditionResult.condition.trim(),
             elements: bodyResult.elements,
           },
         },

package/src/parser/rules/block/include/arguments.ts

@@ -0,0 +1,48 @@
+import type { ParseContext } from "../../types";
+
+export interface IncludeArguments {
+  target: string;
+  argumentTokens: string[];
+  consumed: number;
+}
+
+export function collectIncludeArguments(ctx: ParseContext, startPos: number): IncludeArguments {
+  const argumentTokens: string[] = [];
+  let target = "";
+  let inTarget = true;
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "BLOCK_CLOSE") {
+      break;
+    }
+
+    if (token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    if (inTarget) {
+      if (token.type === "WHITESPACE") {
+        if (target) {
+          inTarget = false;
+        }
+      } else if (token.type === "PIPE") {
+        inTarget = false;
+        argumentTokens.push("|");
+      } else {
+        target += token.value;
+      }
+    } else {
+      argumentTokens.push(token.value);
+    }
+
+    pos++;
+    consumed++;
+  }
+
+  return { target, argumentTokens, consumed };
+}

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

@@ -0,0 +1,75 @@
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseBlockName } from "../utils";
+import { collectIncludeArguments } from "./arguments";
+import { parsePageRef } from "./location";
+import { parseVariables } from "./variables";
+
+export const includeRule: BlockRule = {
+  name: "include",
+  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.toLowerCase() !== "include") {
+      return { success: false };
+    }
+
+    if (!ctx.settings.enablePageSyntax) {
+      return { success: false };
+    }
+
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
+
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+
+    const args = collectIncludeArguments(ctx, pos);
+    pos += args.consumed;
+    consumed += args.consumed;
+
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+
+    if (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+
+    if (!args.target) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "include",
+          data: {
+            "paragraph-safe": false,
+            variables: parseVariables(args.argumentTokens),
+            location: parsePageRef(args.target),
+            elements: [],
+          },
+        },
+      ],
+      consumed,
+    };
+  },
+};

package/src/parser/rules/block/include/location.ts

@@ -0,0 +1,24 @@
+import type { PageRef } from "@wdprlib/ast";
+
+/**
+ * Parse page reference from include target.
+ *
+ * Formats:
+ * - `page` -> `{ site: null, page: "page" }`
+ * - `:site:page` -> `{ site: "site", page: "page" }`
+ * - `fragment:name` -> `{ site: null, page: "fragment:name" }`
+ */
+export function parsePageRef(target: string): PageRef {
+  if (target.startsWith(":")) {
+    const rest = target.slice(1);
+    const colonIndex = rest.indexOf(":");
+    if (colonIndex !== -1) {
+      return {
+        site: rest.slice(0, colonIndex),
+        page: rest.slice(colonIndex + 1),
+      };
+    }
+  }
+
+  return { site: null, page: target };
+}

package/src/parser/rules/block/include/variables.ts

@@ -0,0 +1,37 @@
+import type { VariableMap } from "@wdprlib/ast";
+
+export function parseVariables(tokens: string[]): VariableMap {
+  const vars: VariableMap = {};
+  let current = "";
+
+  for (const token of tokens) {
+    if (token === "|") {
+      assignVariable(vars, current);
+      current = "";
+    } else {
+      current += token;
+    }
+  }
+
+  assignVariable(vars, current);
+
+  return vars;
+}
+
+function assignVariable(vars: VariableMap, source: string): void {
+  if (!source.trim()) {
+    return;
+  }
+
+  const eqIndex = source.indexOf("=");
+  if (eqIndex === -1) {
+    return;
+  }
+
+  const key = source.slice(0, eqIndex).trim();
+  if (!key) {
+    return;
+  }
+
+  vars[key] = source.slice(eqIndex + 1).trim();
+}

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

@@ -0,0 +1,73 @@
+/**
+ *
+ * Block rule for Wikidot marker-based lists (`* item`, `# item`).
+ *
+ * Wikidot lists use leading `*` (bullet) or `#` (numbered) markers at the
+ * start of a line. Nesting is achieved by prepending spaces:
+ *
+ * ```
+ * * Item 1
+ *  * Nested bullet
+ *  # Nested numbered
+ * * Item 2
+ * ```
+ *
+ * The depth of each item is determined by the number of leading spaces
+ * before the marker. Mixed bullet/numbered lists are supported: when the
+ * list type changes at the same depth, a new sub-list is created.
+ *
+ * The flat depth-annotated items are converted into a recursive tree by
+ * `processDepths()`, then transformed into nested `list` AST elements
+ * by `buildListElement()`.
+ *
+ * Maximum nesting depth is capped at `MAX_LIST_DEPTH` (20).
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { buildNativeListElements, collectNativeListLines } from "./native";
+
+/**
+ * Block rule for marker-based lists (`* ` bullet, `# ` numbered).
+ *
+ * Parsing strategy:
+ * 1. Verify the first token is LIST_BULLET or LIST_NUMBER at line start.
+ * 2. Collect consecutive list lines, recording each item's depth (number
+ *    of leading spaces), type (bullet/numbered), and inline content.
+ * 3. Feed the flat depth array into `processDepths()` with type
+ *    comparison, producing a nested tree.
+ * 4. Convert the tree into `list` AST elements via `buildListElement()`.
+ */
+export const listRule: BlockRule = {
+  name: "list",
+  startTokens: ["LIST_BULLET", "LIST_NUMBER"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const firstToken = currentToken(ctx);
+
+    if (!firstToken.lineStart) {
+      return { success: false };
+    }
+
+    // Wikidot: list must start with list marker directly (no leading whitespace)
+    if (firstToken.type !== "LIST_BULLET" && firstToken.type !== "LIST_NUMBER") {
+      return { success: false };
+    }
+
+    const nativeList = collectNativeListLines(ctx);
+
+    // No items parsed - rule fails
+    if (nativeList.lines.length === 0) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: buildNativeListElements(nativeList.lines),
+      consumed: nativeList.consumed,
+    };
+  },
+};

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

@@ -0,0 +1,77 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseInlineUntil } from "../../inline/utils";
+
+/**
+ * Safety limit for list nesting depth.
+ * Items deeper than this are not parsed, preventing stack overflow on
+ * deeply nested or adversarial input.
+ */
+const MAX_LIST_DEPTH = 20;
+
+export type InternalListType = "bullet" | "numbered";
+
+export interface ParsedListLine {
+  depth: number;
+  ltype: InternalListType;
+  value: Element[];
+}
+
+export type ListLineParseResult =
+  | { kind: "parsed"; line: ParsedListLine; consumed: number }
+  | { kind: "stop" };
+
+export function parseNativeListLine(ctx: ParseContext, startPos: number): ListLineParseResult {
+  const firstToken = ctx.tokens[startPos];
+
+  if (!firstToken || !firstToken.lineStart) {
+    return { kind: "stop" };
+  }
+
+  let pos = startPos;
+  let consumed = 0;
+  let depth = 0;
+
+  if (firstToken.type === "WHITESPACE") {
+    depth = firstToken.value.length;
+    pos++;
+    consumed++;
+  }
+
+  const markerToken = ctx.tokens[pos];
+  if (!markerToken || (markerToken.type !== "LIST_BULLET" && markerToken.type !== "LIST_NUMBER")) {
+    return { kind: "stop" };
+  }
+
+  if (depth > MAX_LIST_DEPTH) {
+    return { kind: "stop" };
+  }
+
+  const ltype: InternalListType = markerToken.type === "LIST_BULLET" ? "bullet" : "numbered";
+  pos++;
+  consumed++;
+
+  if (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const inlineCtx: ParseContext = { ...ctx, pos };
+  const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
+  consumed += inlineResult.consumed;
+  pos += inlineResult.consumed;
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return {
+    kind: "parsed",
+    line: {
+      depth,
+      ltype,
+      value: inlineResult.elements,
+    },
+    consumed,
+  };
+}

package/src/parser/rules/block/list/native.ts

@@ -0,0 +1,89 @@
+import type { Element, ListData, ListItem, ListType } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { processDepths, type DepthList } from "../../../depth";
+import { parseNativeListLine, type InternalListType, type ParsedListLine } from "./line";
+
+/**
+ * Default list type used as the top-level placeholder in
+ * `processDepths()`. The actual type of each sub-list is determined
+ * by its first item's marker.
+ */
+const GENERIC_LIST_TYPE: InternalListType = "bullet";
+
+export interface ParsedNativeList {
+  lines: ParsedListLine[];
+  consumed: number;
+}
+
+export function collectNativeListLines(ctx: ParseContext): ParsedNativeList {
+  const lines: ParsedListLine[] = [];
+  let pos = ctx.pos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const result = parseNativeListLine(ctx, pos);
+    if (result.kind === "stop") break;
+
+    lines.push(result.line);
+    pos += result.consumed;
+    consumed += result.consumed;
+  }
+
+  return { lines, consumed };
+}
+
+export function buildNativeListElements(lines: ParsedListLine[]): Element[] {
+  const depthTrees = processDepths<InternalListType, Element[]>(
+    GENERIC_LIST_TYPE,
+    lines,
+    (a, b) => a === b,
+  );
+
+  return depthTrees.map(({ ltype, list }) => buildListElement(ltype, list));
+}
+
+/**
+ * Converts the internal list type enum to the AST's ListType.
+ */
+function toListType(ltype: InternalListType): ListType {
+  return ltype === "numbered" ? "numbered" : "bullet";
+}
+
+function buildListElement(
+  topLtype: InternalListType,
+  list: DepthList<InternalListType, Element[]>,
+): Element {
+  return {
+    element: "list",
+    data: buildListData(topLtype, list),
+  };
+}
+
+function buildListData(
+  topLtype: InternalListType,
+  list: DepthList<InternalListType, Element[]>,
+): ListData {
+  const items: ListItem[] = [];
+
+  for (const item of list) {
+    if (item.kind === "item") {
+      items.push({
+        "item-type": "elements",
+        attributes: {},
+        elements: item.value,
+      });
+    } else {
+      items.push({
+        "item-type": "sub-list",
+        element: "list",
+        data: buildListData(item.ltype, item.children),
+      });
+    }
+  }
+
+  return {
+    type: toListType(topLtype),
+    attributes: {},
+    items,
+  };
+}

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

@@ -0,0 +1,54 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+
+export interface MathContentResult {
+  latexSource: string;
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function collectMathContent(ctx: ParseContext, startPos: number): MathContentResult {
+  let latexSource = "";
+  let pos = startPos;
+  let consumed = 0;
+  let foundClose = false;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token) break;
+
+    if (token.type === "BLOCK_END_OPEN") {
+      const closeNameResult = parseBlockName(ctx, pos + 1);
+      if (closeNameResult?.name === "math") {
+        foundClose = true;
+        break;
+      }
+    }
+
+    latexSource += token.type === "BACKSLASH_BREAK" ? "\\\n" : token.value;
+    pos++;
+    consumed++;
+  }
+
+  return { latexSource, consumed, foundClose };
+}
+
+export function consumeMathClose(ctx: ParseContext, startPos: number): number {
+  let pos = startPos + 1;
+  let consumed = 1;
+
+  const closeNameResult = parseBlockName(ctx, pos);
+  if (closeNameResult) {
+    pos += closeNameResult.consumed;
+    consumed += closeNameResult.consumed;
+  }
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    pos++;
+    consumed++;
+  }
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return consumed;
+}