@wdprlib/parser 3.2.0 → 4.0.0

package/src/parser/rules/block/align.ts

@@ -1,282 +0,0 @@
-/**
- *
- * Block rule for Wikidot alignment containers.
- *
- * Wikidot provides a shorthand bracket syntax for wrapping content in a
- * directional alignment container:
- *
- * ```
- * [[>]]        ... [[/>]]        right-aligned
- * [[<]]        ... [[/<]]        left-aligned
- * [[=]]        ... [[/=]]        center-aligned
- * [[==]]       ... [[/==]]       justify-aligned
- * ```
- *
- * Each pair acts as a block-level wrapper. The opening tag must appear at
- * the start of a line and be followed by a newline. Body content is parsed
- * recursively as block-level markup, and the matching closing tag terminates
- * the container.
- *
- * The resulting AST node is a generic container element whose `type` field
- * carries the alignment direction (e.g. `{ align: "right" }`).
- *
- * @module
- */
-import type { Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseBlocksUntil } from "./utils";
-
-/** The four text-alignment directions Wikidot supports. */
-type AlignDirection = "left" | "right" | "center" | "justify";
-
-/**
- * Attempts to parse the interior of an align opening tag starting after
- * the BLOCK_OPEN (`[[`) token.
- *
- * The function inspects the token(s) immediately following `[[` to determine
- * which alignment direction is requested:
- *
- * | Tokens after `[[`    | Direction   |
- * |----------------------|-------------|
- * | `>` `]]`             | right       |
- * | `<` `]]`             | left        |
- * | `=` `]]`             | center      |
- * | `=` `=` `]]`         | justify     |
- *
- * The `>` character may arrive as either a BLOCKQUOTE_MARKER (when the
- * line starts with `[[`) or as a TEXT token (when it does not).
- *
- * @param ctx - Current parse context.
- * @param pos - Token index right after the BLOCK_OPEN token.
- * @returns The detected direction and how many tokens were consumed,
- *          or `null` if the tokens do not form a valid align open tag.
- */
-function parseAlignOpen(
-  ctx: ParseContext,
-  pos: number,
-): { direction: AlignDirection; consumed: number } | null {
-  const tokens = ctx.tokens;
-
-  // After BLOCK_OPEN, expect specific patterns
-  const firstToken = tokens[pos];
-  if (!firstToken) return null;
-
-  // [[>]] - right
-  if (
-    firstToken.type === "BLOCKQUOTE_MARKER" &&
-    firstToken.value === ">" &&
-    tokens[pos + 1]?.type === "BLOCK_CLOSE"
-  ) {
-    return { direction: "right", consumed: 2 };
-  }
-
-  // Also handle TEXT ">" for non-line-start cases
-  if (
-    firstToken.type === "TEXT" &&
-    firstToken.value === ">" &&
-    tokens[pos + 1]?.type === "BLOCK_CLOSE"
-  ) {
-    return { direction: "right", consumed: 2 };
-  }
-
-  // [[<]] - left (LEFT_DOUBLE_ANGLE might be tokenized, but usually it's after [[)
-  if (
-    firstToken.type === "TEXT" &&
-    firstToken.value === "<" &&
-    tokens[pos + 1]?.type === "BLOCK_CLOSE"
-  ) {
-    return { direction: "left", consumed: 2 };
-  }
-
-  // [[=]] - center (single =)
-  if (firstToken.type === "EQUALS" && tokens[pos + 1]?.type === "BLOCK_CLOSE") {
-    return { direction: "center", consumed: 2 };
-  }
-
-  // [[==]] - justify (double =)
-  if (
-    firstToken.type === "EQUALS" &&
-    tokens[pos + 1]?.type === "EQUALS" &&
-    tokens[pos + 2]?.type === "BLOCK_CLOSE"
-  ) {
-    return { direction: "justify", consumed: 3 };
-  }
-
-  return null;
-}
-
-/**
- * Tests whether the tokens at the current position form a closing align
- * tag (`[[/> ]]`, `[[/< ]]`, `[[/= ]]`, or `[[/== ]]`) that matches
- * the given direction.
- *
- * The closing tag always starts with a BLOCK_END_OPEN token (`[[/`)
- * followed by the same symbol(s) as the opening tag plus BLOCK_CLOSE.
- *
- * @param ctx       - Current parse context (reads from `ctx.pos`).
- * @param direction - The alignment direction of the currently open block,
- *                    used to select the expected closing pattern.
- * @returns An object with `match` (whether the close tag was found) and
- *          `consumed` (number of tokens the closing tag occupies).
- */
-function isAlignClose(
-  ctx: ParseContext,
-  direction: AlignDirection,
-): { match: boolean; consumed: number } {
-  const tokens = ctx.tokens;
-  let pos = ctx.pos;
-
-  if (tokens[pos]?.type !== "BLOCK_END_OPEN") {
-    return { match: false, consumed: 0 };
-  }
-  pos++;
-
-  // [[/>]] - right
-  if (direction === "right") {
-    if (
-      (tokens[pos]?.type === "BLOCKQUOTE_MARKER" || tokens[pos]?.type === "TEXT") &&
-      tokens[pos]?.value === ">" &&
-      tokens[pos + 1]?.type === "BLOCK_CLOSE"
-    ) {
-      return { match: true, consumed: 3 };
-    }
-  }
-
-  // [[/<]] - left
-  if (direction === "left") {
-    if (
-      tokens[pos]?.type === "TEXT" &&
-      tokens[pos]?.value === "<" &&
-      tokens[pos + 1]?.type === "BLOCK_CLOSE"
-    ) {
-      return { match: true, consumed: 3 };
-    }
-  }
-
-  // [[/=]] - center
-  if (direction === "center") {
-    if (tokens[pos]?.type === "EQUALS" && tokens[pos + 1]?.type === "BLOCK_CLOSE") {
-      return { match: true, consumed: 3 };
-    }
-  }
-
-  // [[/==]] - justify
-  if (direction === "justify") {
-    if (
-      tokens[pos]?.type === "EQUALS" &&
-      tokens[pos + 1]?.type === "EQUALS" &&
-      tokens[pos + 2]?.type === "BLOCK_CLOSE"
-    ) {
-      return { match: true, consumed: 4 };
-    }
-  }
-
-  return { match: false, consumed: 0 };
-}
-
-/**
- * Block rule that matches Wikidot directional alignment containers.
- *
- * Parsing strategy:
- * 1. Verify the first token is BLOCK_OPEN at line start.
- * 2. Delegate to `parseAlignOpen()` to identify direction and consume
- *    the opening tag interior.
- * 3. Require a NEWLINE immediately after the opening tag.
- * 4. Recursively parse body blocks via `parseBlocksUntil()`, stopping
- *    when `isAlignClose()` finds the matching closing tag.
- * 5. Consume the closing tag and optional trailing newline.
- * 6. Emit a container element with `type: { align: direction }`.
- *
- * `preservesPrecedingLineBreak` is `true` because, unlike most block
- * constructs, an alignment block does not suppress a preceding `\n` from
- * becoming a `<br />` in Wikidot's output.
- */
-export const alignRule: BlockRule = {
-  name: "align",
-  startTokens: ["BLOCK_OPEN"],
-  requiresLineStart: true,
-  preservesPrecedingLineBreak: true,
-
-  isStartPattern(ctx: ParseContext, pos: number): boolean {
-    if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") return false;
-    return parseAlignOpen(ctx, pos + 1) !== null;
-  },
-
-  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;
-
-    // Parse align open syntax
-    const alignResult = parseAlignOpen(ctx, pos);
-    if (!alignResult) {
-      return { success: false };
-    }
-
-    const { direction } = alignResult;
-    pos += alignResult.consumed;
-    consumed += alignResult.consumed;
-
-    // Must be followed by newline
-    if (ctx.tokens[pos]?.type !== "NEWLINE") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    // Close condition
-    const closeCondition = (checkCtx: ParseContext): boolean => {
-      return isAlignClose(checkCtx, direction).match;
-    };
-
-    // Parse body
-    const bodyCtx: ParseContext = { ...ctx, pos };
-    const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
-    consumed += bodyResult.consumed;
-    pos += bodyResult.consumed;
-
-    // Check for missing close tag
-    const directionSymbol = { left: "<", right: ">", center: "=", justify: "==" }[direction];
-    const closeCheck = isAlignClose({ ...ctx, pos }, direction);
-    if (!closeCheck.match) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: `Missing closing tag [[/${directionSymbol}]] for [[${directionSymbol}]]`,
-        position: openToken.position,
-      });
-    }
-
-    // Consume closing tag
-    if (closeCheck.match) {
-      consumed += closeCheck.consumed;
-      pos += closeCheck.consumed;
-
-      // Consume trailing newline
-      if (ctx.tokens[pos]?.type === "NEWLINE") {
-        pos++;
-        consumed++;
-      }
-    }
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: { align: direction },
-            attributes: {},
-            elements: bodyResult.elements,
-          },
-        },
-      ],
-      consumed,
-    };
-  },
-};

package/src/parser/rules/block/bibliography.ts

@@ -1,359 +0,0 @@
-/**
- *
- * Block rule for the Wikidot bibliography block: `[[bibliography]] ... [[/bibliography]]`.
- *
- * A bibliography block holds labelled citation entries in a definition-list
- * format. Each entry follows the pattern:
- *
- * ```
- * : label : Citation description text
- * ```
- *
- * At render time the entries are cross-referenced with inline `((bibcite label))`
- * markers that appear elsewhere in the document. The parser stores the entries
- * in the AST as a `bibliography-block` element whose `entries` field is an
- * array of {@link DefinitionListItem} objects.
- *
- * Optional attributes on the opening tag:
- * - `title` -- custom heading for the bibliography section.
- * - `hide`  -- when `"true"` or empty string, hides the block from output.
- *
- * If no closing `[[/bibliography]]` tag is found, the rule fails to avoid
- * accidentally consuming the rest of the document.
- *
- * @module
- */
-import type { Element, DefinitionListItem } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseBlockName, parseAttributes } from "./utils";
-import { parseInlineUntil } from "../inline/utils";
-
-/**
- * Internal representation of a single bibliography entry parsed from
- * the `: label : content` line(s) inside the bibliography block.
- */
-interface BibliographyEntry {
-  /** The identifier used in `((bibcite label))` references. */
-  label: string;
-  /** Parsed inline elements for the label portion (the key). */
-  key: Element[];
-  /** Parsed inline elements for the citation text. */
-  content: Element[];
-}
-
-/**
- * Parses one bibliography entry from the token stream.
- *
- * Expected format (one logical line):
- * ```
- * : label : Citation text possibly spanning lines
- * ```
- *
- * The entry starts with a COLON token at line start, followed by mandatory
- * whitespace, then the label text, a second COLON, and the citation content.
- * Content parsing continues until a double newline, a new entry (`: ...`),
- * or the closing `[[/bibliography]]` tag is reached. Single newlines within
- * the citation text produce `line-break` elements.
- *
- * @param ctx      - Current parse context.
- * @param startPos - Token index where the entry begins (expected COLON).
- * @returns The parsed entry and number of tokens consumed, or `null` on failure.
- */
-function parseBibliographyEntry(
-  ctx: ParseContext,
-  startPos: number,
-): { entry: BibliographyEntry; consumed: number } | null {
-  let pos = startPos;
-  let consumed = 0;
-
-  // Expect COLON at line start
-  const colonToken = ctx.tokens[pos];
-  if (!colonToken || colonToken.type !== "COLON" || !colonToken.lineStart) {
-    return null;
-  }
-  pos++;
-  consumed++;
-
-  // Wikidot requires whitespace after first colon
-  const whitespaceAfterColon = ctx.tokens[pos];
-  if (!whitespaceAfterColon || whitespaceAfterColon.type !== "WHITESPACE") {
-    return null;
-  }
-
-  // Skip whitespace after first colon
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-
-  // Collect label tokens until second COLON
-  let label = "";
-  let foundSecondColon = false;
-  const keyNodes: Element[] = [];
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
-      break;
-    }
-    if (token.type === "COLON") {
-      foundSecondColon = true;
-      pos++;
-      consumed++;
-      break;
-    }
-
-    // For bibliography, key is just the label (identifier)
-    label += token.value;
-    keyNodes.push({ element: "text", data: token.value });
-    pos++;
-    consumed++;
-  }
-
-  if (!foundSecondColon) {
-    return null;
-  }
-
-  label = label.trim();
-
-  // Skip whitespace after second colon
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-
-  // Parse content (rest of line, can continue with line breaks)
-  const contentNodes: Element[] = [];
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token || token.type === "EOF") {
-      break;
-    }
-
-    // Check for [[/bibliography]]
-    if (token.type === "BLOCK_END_OPEN") {
-      const closeNameResult = parseBlockName(ctx, pos + 1);
-      if (closeNameResult?.name === "bibliography") {
-        break;
-      }
-    }
-
-    // Check for end of entry (newline followed by new entry or end)
-    if (token.type === "NEWLINE") {
-      const nextToken = ctx.tokens[pos + 1];
-      // Look ahead for new entry or block end
-      if (nextToken?.type === "COLON" && nextToken.lineStart) {
-        // New entry starts
-        pos++;
-        consumed++;
-        break;
-      }
-      if (nextToken?.type === "BLOCK_END_OPEN") {
-        // Block end
-        pos++;
-        consumed++;
-        break;
-      }
-      if (nextToken?.type === "NEWLINE" || !nextToken || nextToken.type === "EOF") {
-        // Double newline or end
-        pos++;
-        consumed++;
-        break;
-      }
-      // Single newline - add line break and continue
-      contentNodes.push({ element: "line-break" });
-      pos++;
-      consumed++;
-      continue;
-    }
-
-    // Parse inline content
-    const inlineCtx: ParseContext = { ...ctx, pos };
-    const result = parseInlineUntil(inlineCtx, "NEWLINE");
-    if (result.elements.length > 0) {
-      contentNodes.push(...result.elements);
-      pos += result.consumed;
-      consumed += result.consumed;
-    } else {
-      pos++;
-      consumed++;
-    }
-  }
-
-  // Trim key nodes
-  while (keyNodes.length > 0) {
-    const lastNode = keyNodes[keyNodes.length - 1];
-    if (
-      lastNode &&
-      lastNode.element === "text" &&
-      typeof lastNode.data === "string" &&
-      lastNode.data.trim() === ""
-    ) {
-      keyNodes.pop();
-    } else {
-      break;
-    }
-  }
-
-  return {
-    entry: {
-      label,
-      key: keyNodes,
-      content: contentNodes,
-    },
-    consumed,
-  };
-}
-
-/**
- * Block rule for Wikidot `[[bibliography]]...[[/bibliography]]`.
- *
- * Parsing strategy:
- * 1. Match BLOCK_OPEN + block name "bibliography".
- * 2. Parse optional attributes (`title`, `hide`).
- * 3. Consume the closing `]]` and optional newline.
- * 4. Loop over the body, parsing each `: label : content` line via
- *    `parseBibliographyEntry()`. Whitespace, newlines, and unknown
- *    tokens between entries are skipped.
- * 5. Stop when `[[/bibliography]]` is found and consume it.
- * 6. If no closing tag is encountered, fail the rule entirely.
- * 7. Convert entries into {@link DefinitionListItem} format and emit
- *    a `bibliography-block` element.
- */
-export const bibliographyRule: BlockRule = {
-  name: "bibliography",
-  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;
-
-    // Parse block name
-    const nameResult = parseBlockName(ctx, pos);
-    if (!nameResult || nameResult.name !== "bibliography") {
-      return { success: false };
-    }
-
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
-
-    // Parse optional attributes (title, hide)
-    const attrResult = parseAttributes(ctx, pos);
-    pos += attrResult.consumed;
-    consumed += attrResult.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++;
-    }
-
-    // Parse bibliography entries
-    const entries: BibliographyEntry[] = [];
-    let foundClose = false;
-
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (!token || token.type === "EOF") {
-        break;
-      }
-
-      // Check for [[/bibliography]]
-      if (token.type === "BLOCK_END_OPEN") {
-        const closeNameResult = parseBlockName(ctx, pos + 1);
-        if (closeNameResult?.name === "bibliography") {
-          foundClose = true;
-          // Consume [[/bibliography]]
-          pos++;
-          consumed++;
-          pos += closeNameResult.consumed;
-          consumed += closeNameResult.consumed;
-          // Skip whitespace
-          while (ctx.tokens[pos]?.type === "WHITESPACE") {
-            pos++;
-            consumed++;
-          }
-          // Expect ]]
-          if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
-            pos++;
-            consumed++;
-          }
-          break;
-        }
-      }
-
-      // Skip whitespace and newlines
-      if (token.type === "WHITESPACE" || token.type === "NEWLINE") {
-        pos++;
-        consumed++;
-        continue;
-      }
-
-      // Parse entry
-      if (token.type === "COLON" && token.lineStart) {
-        const result = parseBibliographyEntry(ctx, pos);
-        if (result) {
-          entries.push(result.entry);
-          pos += result.consumed;
-          consumed += result.consumed;
-          continue;
-        }
-      }
-
-      // Skip unknown tokens
-      pos++;
-      consumed++;
-    }
-
-    // Require closing tag - without it, fail to prevent consuming entire document
-    if (!foundClose) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: "Missing closing tag [[/bibliography]] for [[bibliography]]",
-        position: openToken.position,
-      });
-      return { success: false };
-    }
-
-    // Convert to definition list format for AST storage
-    const definitionItems: DefinitionListItem[] = entries.map((entry) => ({
-      key_string: entry.label,
-      key: entry.key,
-      value: entry.content,
-    }));
-
-    // Get attributes
-    const title = attrResult.attrs.title ?? null;
-    const hide = attrResult.attrs.hide === "true" || attrResult.attrs.hide === "";
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "bibliography-block",
-          data: {
-            entries: definitionItems,
-            title: typeof title === "string" ? title : null,
-            hide,
-          },
-        },
-      ],
-      consumed,
-    };
-  },
-};