@wdprlib/parser 3.2.0 → 4.0.0

package/src/parser/rules/inline/anchor-name/syntax.ts

@@ -0,0 +1,46 @@
+import type { ParseContext } from "../../types";
+import { collectAnchorName } from "./name";
+
+export function parseAnchorNameTarget(
+  ctx: ParseContext,
+  startPos: number,
+): { name: string; consumed: number } | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const hashToken = ctx.tokens[pos];
+  if (
+    !hashToken ||
+    (hashToken.type !== "HASH" && !(hashToken.type === "TEXT" && hashToken.value === "#"))
+  ) {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  if (ctx.tokens[pos]?.type !== "WHITESPACE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const nameResult = collectAnchorName(ctx, pos);
+  if (!nameResult || ctx.tokens[pos + nameResult.consumed]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+
+  return {
+    name: nameResult.name,
+    consumed: consumed + nameResult.consumed + 1,
+  };
+}

package/src/parser/rules/inline/bibcite/element.ts

@@ -0,0 +1,14 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+
+export function buildBibliographyCitation(ctx: ParseContext, label: string): Element {
+  ctx.bibcites.push(label);
+
+  return {
+    element: "bibliography-cite",
+    data: {
+      label,
+      brackets: false,
+    },
+  };
+}

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

@@ -0,0 +1,34 @@
+/**
+ *
+ * Parses the Wikidot bibliography citation syntax: `((bibcite label))`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { buildBibliographyCitation } from "./element";
+import { parseBibciteLabel } from "./syntax";
+
+export const bibciteRule: InlineRule = {
+  name: "bibcite",
+  startTokens: ["TEXT"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const token = currentToken(ctx);
+    if (token.type !== "TEXT" || token.value !== "(") {
+      return { success: false };
+    }
+
+    const parsed = parseBibciteLabel(ctx, ctx.pos);
+    if (!parsed) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [buildBibliographyCitation(ctx, parsed.label)],
+      consumed: parsed.consumed,
+    };
+  },
+};

package/src/parser/rules/inline/bibcite/syntax.ts

@@ -0,0 +1,64 @@
+import type { ParseContext } from "../../types";
+
+export function parseBibciteLabel(
+  ctx: ParseContext,
+  startPos: number,
+): { label: string; consumed: number } | null {
+  if (ctx.tokens[startPos]?.type !== "TEXT" || ctx.tokens[startPos]?.value !== "(") {
+    return null;
+  }
+  if (ctx.tokens[startPos + 1]?.type !== "TEXT" || ctx.tokens[startPos + 1]?.value !== "(") {
+    return null;
+  }
+
+  let pos = startPos + 2;
+  let consumed = 2;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const nameToken = ctx.tokens[pos];
+  if (
+    !nameToken ||
+    nameToken.type !== "IDENTIFIER" ||
+    nameToken.value.toLowerCase() !== "bibcite"
+  ) {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const labelToken = ctx.tokens[pos];
+  if (!labelToken || (labelToken.type !== "IDENTIFIER" && labelToken.type !== "TEXT")) {
+    return null;
+  }
+
+  let label = "";
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
+      return null;
+    }
+
+    if (token.type === "TEXT" && token.value === ")") {
+      const nextToken = ctx.tokens[pos + 1];
+      if (nextToken?.type === "TEXT" && nextToken.value === ")") {
+        const trimmed = label.trim();
+        return trimmed ? { label: trimmed, consumed: consumed + 2 } : null;
+      }
+    }
+
+    label += token.value;
+    pos++;
+    consumed++;
+  }
+
+  return null;
+}

package/src/parser/rules/inline/bold.ts

@@ -18,8 +18,7 @@
  */
 import type { Element } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { currentToken, hasClosingMarkerBeforeNewline } from "../types";
-import { parseInlineUntil } from "./utils";
+import { parseSameLineDelimitedContainer } from "./formatting/container";
 
 /**
  * Inline rule for parsing `**bold**` formatting.
@@ -45,42 +44,6 @@ export const boldRule: InlineRule = {
    *          fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    const startToken = currentToken(ctx);
-
-    // Check if closing marker exists
-    if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "BOLD_MARKER")) {
-      return {
-        success: true,
-        elements: [{ element: "text", data: startToken.value }],
-        consumed: 1,
-      };
-    }
-
-    // Parse content between markers
-    const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "BOLD_MARKER");
-
-    // Empty bold (****) is discarded entirely in Wikidot
-    if (result.elements.length === 0) {
-      return {
-        success: true,
-        elements: [],
-        consumed: 1 + result.consumed + 1,
-      };
-    }
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "bold",
-            attributes: {},
-            elements: result.elements,
-          },
-        },
-      ],
-      consumed: 1 + result.consumed + 1, // open + content + close
-    };
+    return parseSameLineDelimitedContainer(ctx, "BOLD_MARKER", "bold", { discardEmpty: true });
   },
 };

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

@@ -0,0 +1,35 @@
+/**
+ *
+ * Parses the Wikidot inline color syntax: `##color|text##`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { parseColorContent } from "./syntax";
+
+export const colorRule: InlineRule = {
+  name: "color",
+  startTokens: ["COLOR_MARKER"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const parsed = parseColorContent(ctx);
+    if (!parsed) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "color",
+          data: {
+            color: parsed.color,
+            elements: parsed.elements,
+          },
+        },
+      ],
+      consumed: parsed.consumed,
+    };
+  },
+};

package/src/parser/rules/inline/color/syntax.ts

@@ -0,0 +1,69 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { hasClosingMarkerBeforeNewline } from "../../types";
+import { parseInlineUntil } from "../utils";
+
+export interface ColorContent {
+  color: string;
+  elements: Element[];
+  consumed: number;
+}
+
+export function parseColorContent(ctx: ParseContext): ColorContent | null {
+  if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "COLOR_MARKER")) {
+    return null;
+  }
+
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+  let colorSpec = "";
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "PIPE" ||
+      token.type === "COLOR_MARKER" ||
+      token.type === "NEWLINE" ||
+      token.type === "EOF"
+    ) {
+      break;
+    }
+    colorSpec += token.value;
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type !== "PIPE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  const contentResult = parseInlineUntil({ ...ctx, pos }, "COLOR_MARKER");
+  pos += contentResult.consumed;
+  consumed += contentResult.consumed;
+
+  if (ctx.tokens[pos]?.type !== "COLOR_MARKER") {
+    return null;
+  }
+  consumed++;
+
+  const color = colorSpec.trim();
+  if (color === "" || contentResult.elements.length === 0) {
+    return null;
+  }
+
+  return {
+    color: hexifyColor(color),
+    elements: contentResult.elements,
+    consumed,
+  };
+}
+
+function hexifyColor(color: string): string {
+  if (/^[a-fA-F0-9]{3}$/.test(color) || /^[a-fA-F0-9]{6}$/.test(color)) {
+    return `#${color}`;
+  }
+  return color;
+}

package/src/parser/rules/inline/comment/consume.ts

@@ -0,0 +1,31 @@
+import type { ParseContext } from "../../types";
+
+export interface CommentConsumeResult {
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function consumeInlineComment(ctx: ParseContext, startPos: number): CommentConsumeResult {
+  let pos = startPos + 1;
+  let consumed = 1;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token) {
+      break;
+    }
+
+    if (token.type === "COMMENT_CLOSE") {
+      return { consumed: consumed + 1, foundClose: true };
+    }
+
+    if (token.type === "EOF") {
+      return { consumed, foundClose: false };
+    }
+
+    pos++;
+    consumed++;
+  }
+
+  return { consumed, foundClose: false };
+}

package/src/parser/rules/inline/{comment.ts → comment/index.ts}

@@ -17,8 +17,9 @@
  * @module
  */
 import type { Element } from "@wdprlib/ast";
-import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { consumeInlineComment } from "./consume";
 
 /**
  * Inline rule for parsing `[!-- comment --]` syntax.
@@ -43,40 +44,13 @@ export const commentRule: InlineRule = {
    */
   parse(ctx: ParseContext): RuleResult<Element> {
     const openToken = currentToken(ctx);
-    let pos = ctx.pos + 1; // skip [!--
-    let consumed = 1;
-
-    // Consume all tokens until we find --]
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (!token) {
-        break;
-      }
-
-      if (token.type === "COMMENT_CLOSE") {
-        consumed++;
-        pos++;
-        // Return empty result - comment is discarded
-        return {
-          success: true,
-          elements: [],
-          consumed,
-        };
-      }
-
-      if (token.type === "EOF") {
-        // Unterminated comment - fail
-        ctx.diagnostics.push({
-          severity: "warning",
-          code: "unclosed-comment",
-          message: "Unterminated comment: missing closing --]",
-          position: openToken.position,
-        });
-        return { success: false };
-      }
-
-      pos++;
-      consumed++;
+    const comment = consumeInlineComment(ctx, ctx.pos);
+    if (comment.foundClose) {
+      return {
+        success: true,
+        elements: [],
+        consumed: comment.consumed,
+      };
     }
 
     ctx.diagnostics.push({

package/src/parser/rules/inline/equation-ref/element.ts

@@ -0,0 +1,8 @@
+import type { Element } from "@wdprlib/ast";
+
+export function equationReferenceElement(name: string): Element {
+  return {
+    element: "equation-reference",
+    data: name,
+  };
+}

package/src/parser/rules/inline/equation-ref/index.ts

@@ -0,0 +1,34 @@
+/**
+ *
+ * Parses the Wikidot equation reference syntax: `[[eref name]]`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { equationReferenceElement } from "./element";
+import { parseEquationRefName } from "./syntax";
+
+export const equationRefRule: InlineRule = {
+  name: "equation-ref",
+  startTokens: ["BLOCK_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const parsed = parseEquationRefName(ctx, ctx.pos + 1);
+    if (!parsed) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [equationReferenceElement(parsed.name)],
+      consumed: 1 + parsed.consumed,
+    };
+  },
+};

package/src/parser/rules/inline/equation-ref/syntax.ts

@@ -0,0 +1,45 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../../common";
+
+export function parseEquationRefName(
+  ctx: ParseContext,
+  startPos: number,
+): { name: string; consumed: number } | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult || nameResult.name.toLowerCase() !== "eref") {
+    return null;
+  }
+
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  let refName = "";
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "BLOCK_CLOSE" || token.type === "NEWLINE") {
+      break;
+    }
+    refName += token.value;
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+
+  refName = refName.trim();
+  if (!refName) {
+    return null;
+  }
+
+  return { name: refName, consumed: consumed + 1 };
+}

package/src/parser/rules/inline/expr/branch.ts

@@ -0,0 +1,104 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { getCandidateInlineRules } from "../utils";
+import { advanceExprDepth } from "./depth";
+
+export interface BranchParseResult {
+  elements: Element[];
+  consumed: number;
+  endedWithPipe: boolean;
+}
+
+export interface ExpressionTextResult {
+  text: string;
+  consumed: number;
+  endedWithPipe: boolean;
+}
+
+/**
+ * Parses inline content for the then/else branches of `[[#if]]` and `[[#ifexpr]]`.
+ */
+export function parseInlineBranch(ctx: ParseContext, startPos: number): BranchParseResult {
+  const elements: Element[] = [];
+  let consumed = 0;
+  let pos = startPos;
+  let depth = 0;
+
+  const { inlineRules } = ctx;
+  const inlineCtx: ParseContext = { ...ctx, pos };
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF" || token.type === "NEWLINE") {
+      break;
+    }
+
+    const nextDepth = advanceExprDepth(token, depth);
+    if (nextDepth.shouldBreak) {
+      break;
+    }
+    depth = nextDepth.depth;
+
+    if (token.type === "PIPE" && depth === 0) {
+      return { elements, consumed, endedWithPipe: true };
+    }
+
+    inlineCtx.pos = pos;
+    let matched = false;
+
+    for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
+      if (rule.startTokens.includes("PIPE") || rule.startTokens.includes("BLOCK_CLOSE")) {
+        continue;
+      }
+      const result = rule.parse(inlineCtx);
+      if (result.success) {
+        elements.push(...result.elements);
+        consumed += result.consumed;
+        pos += result.consumed;
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) {
+      elements.push({ element: "text", data: token.value });
+      consumed++;
+      pos++;
+    }
+  }
+
+  return { elements, consumed, endedWithPipe: false };
+}
+
+/**
+ * Collects raw text for the expression or condition portion of expr rules.
+ */
+export function collectExpressionText(ctx: ParseContext, startPos: number): ExpressionTextResult {
+  const parts: string[] = [];
+  let consumed = 0;
+  let pos = startPos;
+  let depth = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF" || token.type === "NEWLINE") {
+      break;
+    }
+
+    const nextDepth = advanceExprDepth(token, depth);
+    if (nextDepth.shouldBreak) {
+      break;
+    }
+    depth = nextDepth.depth;
+
+    if (token.type === "PIPE" && depth === 0) {
+      return { text: parts.join("").trim(), consumed, endedWithPipe: true };
+    }
+
+    parts.push(token.value);
+    consumed++;
+    pos++;
+  }
+
+  return { text: parts.join("").trim(), consumed, endedWithPipe: false };
+}

package/src/parser/rules/inline/expr/conditional-branch.ts

@@ -0,0 +1,27 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseInlineBranch } from "./branch";
+import { skipWhitespace } from "./syntax";
+
+export interface ConditionalBranchResult {
+  elements: Element[];
+  consumed: number;
+  nextPos: number;
+  endedWithPipe: boolean;
+}
+
+export function parseConditionalBranch(
+  ctx: ParseContext,
+  startPos: number,
+): ConditionalBranchResult {
+  const branchStart = skipWhitespace(ctx, startPos);
+  const leadingWhitespaceConsumed = branchStart - startPos;
+  const branchResult = parseInlineBranch(ctx, branchStart);
+
+  return {
+    elements: branchResult.elements,
+    consumed: leadingWhitespaceConsumed + branchResult.consumed,
+    nextPos: branchStart + branchResult.consumed,
+    endedWithPipe: branchResult.endedWithPipe,
+  };
+}