@wdprlib/parser 3.1.2 → 4.0.0

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

@@ -0,0 +1,40 @@
+import type { ParseContext } from "../../types";
+
+export interface AnchorBlockName {
+  name: string;
+  paragraphStrip: boolean;
+  consumed: number;
+}
+
+export function parseAnchorBlockName(ctx: ParseContext, startPos: number): AnchorBlockName | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const token = ctx.tokens[pos];
+  if (!token || (token.type !== "TEXT" && token.type !== "IDENTIFIER")) {
+    return null;
+  }
+
+  let name = token.value.toLowerCase();
+  consumed++;
+  pos++;
+
+  let paragraphStrip = false;
+  if (ctx.tokens[pos]?.type === "UNDERSCORE") {
+    paragraphStrip = true;
+    name += "_";
+    consumed++;
+  }
+
+  return { name, paragraphStrip, consumed };
+}
+
+export function isAnchorBlockName(name: string): boolean {
+  const baseName = name.replace(/_$/, "");
+  return baseName === "a" || baseName === "anchor";
+}

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

@@ -0,0 +1,38 @@
+/**
+ *
+ * Parses the Wikidot named anchor syntax: `[[# name]]`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseAnchorNameTarget } from "./syntax";
+
+export const anchorNameRule: InlineRule = {
+  name: "anchorName",
+  startTokens: ["BLOCK_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const target = parseAnchorNameTarget(ctx, ctx.pos + 1);
+    if (!target) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "anchor-name",
+          data: target.name,
+        },
+      ],
+      consumed: 1 + target.consumed,
+    };
+  },
+};

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

@@ -0,0 +1,39 @@
+import type { ParseContext } from "../../types";
+
+export function collectAnchorName(
+  ctx: ParseContext,
+  startPos: number,
+): { name: string; consumed: number } | null {
+  let pos = startPos;
+  let consumed = 0;
+  let name = "";
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "BLOCK_CLOSE" ||
+      token.type === "NEWLINE" ||
+      token.type === "EOF"
+    ) {
+      break;
+    }
+    if (!isValidAnchorNameToken(token.value)) {
+      break;
+    }
+    name += token.value;
+    pos++;
+    consumed++;
+  }
+
+  return name ? { name, consumed } : null;
+}
+
+function isValidAnchorNameToken(value: string): boolean {
+  for (const char of value) {
+    if (!/^[-_A-Za-z0-9.%]$/.test(char)) {
+      return false;
+    }
+  }
+  return true;
+}

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

@@ -0,0 +1,49 @@
+/**
+ *
+ * Parses the Wikidot bold formatting syntax: `**text**`.
+ *
+ * Bold text is delimited by double asterisks. The opening and closing
+ * markers must appear on the same line; if no closing `**` is found
+ * before a newline, the opening marker is emitted as literal text.
+ *
+ * Wikidot behavior for empty bold (`****`): the markers and their
+ * (empty) content are discarded entirely, producing no output.
+ *
+ * Bold may nest other inline formatting (italic, underline, etc.)
+ * within its body.
+ *
+ * Produces a `"container"` AST element with `type: "bold"`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../types";
+import { parseSameLineDelimitedContainer } from "./formatting/container";
+
+/**
+ * Inline rule for parsing `**bold**` formatting.
+ *
+ * Triggered by a `BOLD_MARKER` token (`**`). The rule checks for a
+ * matching closing marker on the same line, then recursively parses
+ * inline content between the markers.
+ *
+ * When no closing marker is found, the opening `**` is treated as
+ * literal text rather than causing a parse failure, preserving
+ * Wikidot's graceful-degradation behavior.
+ */
+export const boldRule: InlineRule = {
+  name: "bold",
+  startTokens: ["BOLD_MARKER"],
+
+  /**
+   * Attempts to parse bold formatting at the current position.
+   *
+   * @param ctx - Parse context with token stream and current position
+   * @returns A successful result containing either a `"container"` element
+   *          with `type: "bold"`, an empty array (for `****`), or a text
+   *          fallback for unmatched markers
+   */
+  parse(ctx: ParseContext): RuleResult<Element> {
+    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/index.ts

@@ -0,0 +1,64 @@
+/**
+ *
+ * Parses the Wikidot comment syntax: `[!-- text --]`.
+ *
+ * Comments are completely removed from the rendered output. Any content
+ * between the opening `[!--` and closing `--]` markers is consumed and
+ * discarded. Comments may contain arbitrary text, including markup
+ * characters that would otherwise be interpreted.
+ *
+ * If the closing `--]` is never found (unterminated comment), the rule
+ * fails and the opening `[!--` falls through to other rules or the
+ * text fallback.
+ *
+ * Unlike HTML comments (`<!-- -->`), Wikidot comments use square
+ * brackets with exclamation marks.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { consumeInlineComment } from "./consume";
+
+/**
+ * Inline rule for parsing `[!-- comment --]` syntax.
+ *
+ * Triggered by a `COMMENT_OPEN` token (`[!--`). Consumes all tokens
+ * until a `COMMENT_CLOSE` (`--]`) token is found, then returns an
+ * empty elements array (discarding the comment content).
+ *
+ * Comments may span across newlines. However, if an EOF is reached
+ * before the closing marker, the parse fails.
+ */
+export const commentRule: InlineRule = {
+  name: "comment",
+  startTokens: ["COMMENT_OPEN"],
+
+  /**
+   * Attempts to parse a comment at the current position.
+   *
+   * @param ctx - Parse context with token stream and current position
+   * @returns A successful result with an empty elements array (comment discarded),
+   *          or `{ success: false }` if the comment is unterminated
+   */
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    const comment = consumeInlineComment(ctx, ctx.pos);
+    if (comment.foundClose) {
+      return {
+        success: true,
+        elements: [],
+        consumed: comment.consumed,
+      };
+    }
+
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-comment",
+      message: "Unterminated comment: missing closing --]",
+      position: openToken.position,
+    });
+    return { success: false };
+  },
+};

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 };
+}