@wdprlib/parser 3.2.0 → 4.1.0

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

@@ -1,331 +0,0 @@
-/**
- *
- * Block rule for Wikidot tabbed content: `[[tabview]]` (or `[[tabs]]`).
- *
- * A tabview contains one or more `[[tab Label]]...[[/tab]]` blocks:
- *
- * ```
- * [[tabview]]
- * [[tab First Tab]]
- * Content of the first tab.
- * [[/tab]]
- * [[tab Second Tab]]
- * Content of the second tab.
- * [[/tab]]
- * [[/tabview]]
- * ```
- *
- * Key behaviours:
- * - Both `[[tabview]]` and `[[tabs]]` are accepted as the outer wrapper.
- * - Any attributes or text after the block name on the opening tag are
- *   silently ignored (Wikidot behaviour: `[[tabview Foo]]` is valid).
- * - If a tab has no label, it defaults to `"untitled"`.
- * - Tab body content is parsed as block-level markup.
- * - An empty tabview (no tabs) fails the rule, falling back to text.
- * - Non-tab content between tabs (other than whitespace/newlines) causes
- *   the rule to fail.
- *
- * @module
- */
-import type { Element, TabData } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseBlockName, parseBlocksUntil } from "./utils";
-
-/**
- * Parses a single `[[tab Label]]...[[/tab]]` block within a tabview.
- *
- * The label is everything between the block name and `]]` (leading
- * whitespace is trimmed). An empty label defaults to `"untitled"`.
- * Newlines are not allowed in the label -- if one is encountered, the
- * parse fails.
- *
- * Body content is parsed as block-level markup via {@link parseBlocksUntil}.
- *
- * @param ctx - Parse context, positioned before the expected `[[tab ...]]`.
- * @returns The tab data and consumed count, or `null` on failure.
- */
-function parseTab(ctx: ParseContext): { tab: TabData; consumed: number } | null {
-  let pos = ctx.pos;
-  let consumed = 0;
-
-  // Skip whitespace/newlines before tab
-  while (ctx.tokens[pos]?.type === "WHITESPACE" || ctx.tokens[pos]?.type === "NEWLINE") {
-    pos++;
-    consumed++;
-  }
-
-  // Expect [[
-  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") {
-    return null;
-  }
-  pos++;
-  consumed++;
-
-  // Parse block name
-  const nameResult = parseBlockName(ctx, pos);
-  if (!nameResult || nameResult.name.toLowerCase() !== "tab") {
-    return null;
-  }
-  pos += nameResult.consumed;
-  consumed += nameResult.consumed;
-
-  // Parse label (everything until ]])
-  let label = "";
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token) break;
-    if (token.type === "BLOCK_CLOSE") {
-      break;
-    }
-    if (token.type === "NEWLINE") {
-      // No newline allowed in label
-      return null;
-    }
-    // Skip leading whitespace in label
-    if (label === "" && token.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-      continue;
-    }
-    label += token.value;
-    pos++;
-    consumed++;
-  }
-
-  // Expect ]]
-  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-    return null;
-  }
-  pos++;
-  consumed++;
-
-  // Skip newline after opening tag
-  if (ctx.tokens[pos]?.type === "NEWLINE") {
-    pos++;
-    consumed++;
-  }
-
-  // Close condition for [[/tab]]
-  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() === "tab") {
-        return true;
-      }
-    }
-    return false;
-  };
-
-  // Parse body
-  const bodyCtx: ParseContext = { ...ctx, pos };
-  const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
-  consumed += bodyResult.consumed;
-  pos += bodyResult.consumed;
-
-  // Check for missing close tag
-  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
-    ctx.diagnostics.push({
-      severity: "warning",
-      code: "unclosed-block",
-      message: "Missing closing tag [[/tab]] for [[tab]]",
-      position: ctx.tokens[ctx.pos]?.position ?? {
-        start: { line: 0, column: 0, offset: 0 },
-        end: { line: 0, column: 0, offset: 0 },
-      },
-    });
-  }
-
-  // Consume [[/tab]]
-  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++;
-    }
-    // Skip trailing newline
-    if (ctx.tokens[pos]?.type === "NEWLINE") {
-      pos++;
-      consumed++;
-    }
-  }
-
-  // Default label if empty
-  const finalLabel = label.trim() || "untitled";
-
-  return {
-    tab: {
-      label: finalLabel,
-      elements: bodyResult.elements,
-    },
-    consumed,
-  };
-}
-
-/**
- * Block rule for `[[tabview]]`/`[[tabs]]` with `[[tab]]` children.
- *
- * Parsing strategy:
- * 1. Match BLOCK_OPEN + name "tabview" or "tabs" (case-insensitive).
- * 2. Skip any trailing text/attributes on the opening tag (ignored).
- * 3. Consume `]]` and optional newline.
- * 4. Repeatedly parse `[[tab Label]]...[[/tab]]` blocks via `parseTab()`.
- * 5. Whitespace and newlines between tabs are skipped; other content fails.
- * 6. Consume `[[/tabview]]` or `[[/tabs]]`.
- * 7. If no tabs were found, fail the rule.
- * 8. Emit a `tab-view` element containing the array of tab data.
- */
-export const tabviewRule: BlockRule = {
-  name: "tabview",
-  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) {
-      return { success: false };
-    }
-
-    const blockName = nameResult.name.toLowerCase();
-    // Accept tabview or tabs
-    if (blockName !== "tabview" && blockName !== "tabs") {
-      return { success: false };
-    }
-
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
-
-    // Skip any attributes/name (Wikidot ignores [[tabview Foo]])
-    while (
-      pos < ctx.tokens.length &&
-      ctx.tokens[pos]?.type !== "BLOCK_CLOSE" &&
-      ctx.tokens[pos]?.type !== "NEWLINE"
-    ) {
-      pos++;
-      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 tabs
-    const tabs: TabData[] = [];
-    const tabCtx: ParseContext = { ...ctx, pos };
-
-    while (pos < ctx.tokens.length) {
-      // Check for EOF
-      if (ctx.tokens[pos]?.type === "EOF") {
-        break;
-      }
-
-      // Check for closing [[/tabview]] or [[/tabs]]
-      if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
-        const closeNameResult = parseBlockName(ctx, pos + 1);
-        const closeName = closeNameResult?.name.toLowerCase();
-        if (closeName === "tabview" || closeName === "tabs") {
-          break;
-        }
-      }
-
-      // Try to parse a tab
-      const tabResult = parseTab({ ...tabCtx, pos });
-      if (tabResult) {
-        tabs.push(tabResult.tab);
-        pos += tabResult.consumed;
-        consumed += tabResult.consumed;
-      } else {
-        // Skip whitespace/newlines between tabs
-        if (ctx.tokens[pos]?.type === "WHITESPACE" || ctx.tokens[pos]?.type === "NEWLINE") {
-          pos++;
-          consumed++;
-        } else {
-          // Non-tab content in tabview - fail
-          return { success: false };
-        }
-      }
-    }
-
-    // Check for missing close tag
-    const hasTabviewClose =
-      ctx.tokens[pos]?.type === "BLOCK_END_OPEN" &&
-      (() => {
-        const n = parseBlockName(ctx, pos + 1);
-        const name = n?.name.toLowerCase();
-        return name === "tabview" || name === "tabs";
-      })();
-    if (!hasTabviewClose) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: `Missing closing tag [[/${blockName}]] for [[${blockName}]]`,
-        position: openToken.position,
-      });
-    }
-
-    // Consume [[/tabview]] or [[/tabs]]
-    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++;
-      }
-    }
-
-    // Empty tabview is invalid - return failure so it falls back to plain text.
-    // Note: Ideally, a failed tabview like "EMPTY:\n[[tabview]]\n[[/tabview]]" should
-    // render as a single paragraph with <br /> separators (matching original Wikidot).
-    // Currently, the paragraph parser treats [[tabview]] as a block-start token and
-    // splits it into separate paragraphs. We chose to wrap each in <p> tags instead
-    // of implementing complex lookahead to detect invalid tabviews.
-    if (tabs.length === 0) {
-      return { success: false };
-    }
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "tab-view",
-          data: tabs,
-        },
-      ],
-      consumed,
-    };
-  },
-};

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

@@ -1,129 +0,0 @@
-/**
- * Table of contents rule: [[toc]], [[f<toc ...]], [[f>toc ...]]
- *
- * Variants:
- * - [[toc]] - basic TOC
- * - [[f<toc ...]] - float left
- * - [[f>toc ...]] - float right
- *
- * Note: Wikidot ignores attributes on [[toc]] (class, style, id are not applied)
- * [[>toc]] and [[<toc]] are invalid in Wikidot and not supported.
- */
-import type { Alignment, Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-
-/**
- * Skip tokens until BLOCK_CLOSE (Wikidot ignores toc attributes)
- */
-function skipUntilClose(ctx: ParseContext, startPos: number): number {
-  let pos = startPos;
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (
-      !token ||
-      token.type === "BLOCK_CLOSE" ||
-      token.type === "NEWLINE" ||
-      token.type === "EOF"
-    ) {
-      break;
-    }
-    pos++;
-  }
-  return pos;
-}
-
-export const tocRule: BlockRule = {
-  name: "toc",
-  startTokens: ["BLOCK_OPEN"],
-  requiresLineStart: true,
-
-  parse(ctx: ParseContext): RuleResult<Element> {
-    const openToken = currentToken(ctx);
-    if (openToken.type !== "BLOCK_OPEN") {
-      return { success: false };
-    }
-
-    let pos = ctx.pos + 1;
-    let align: Alignment | null = null;
-
-    // Skip whitespace after [[
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-    }
-
-    const firstToken = ctx.tokens[pos];
-    if (!firstToken || (firstToken.type !== "TEXT" && firstToken.type !== "IDENTIFIER")) {
-      return { success: false };
-    }
-
-    const firstValue = firstToken.value.toLowerCase();
-
-    if (firstValue === "toc") {
-      // [[toc ...]]
-      // Page syntax disabled (e.g., forum-post mode)
-      if (!ctx.settings.enablePageSyntax) {
-        return { success: false };
-      }
-      pos++;
-    } else if (firstValue === "f") {
-      // Possibly [[f<toc ...]] or [[f>toc ...]]
-      pos++;
-      const dirToken = ctx.tokens[pos];
-      if (!dirToken) {
-        return { success: false };
-      }
-
-      if (dirToken.type === "TEXT" && dirToken.value === "<") {
-        align = "left";
-        pos++;
-      } else if (dirToken.type === "TEXT" && dirToken.value === ">") {
-        align = "right";
-        pos++;
-      } else {
-        return { success: false };
-      }
-
-      // Now expect "toc"
-      const tocToken = ctx.tokens[pos];
-      if (!tocToken || (tocToken.type !== "TEXT" && tocToken.type !== "IDENTIFIER")) {
-        return { success: false };
-      }
-      if (tocToken.value.toLowerCase() !== "toc") {
-        return { success: false };
-      }
-      // Page syntax disabled (e.g., forum-post mode)
-      if (!ctx.settings.enablePageSyntax) {
-        return { success: false };
-      }
-      pos++;
-    } else {
-      return { success: false };
-    }
-
-    // Skip any tokens until ]] (Wikidot ignores toc attributes)
-    pos = skipUntilClose(ctx, pos);
-
-    // Expect ]]
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-      return { success: false };
-    }
-    pos++;
-
-    const consumed = pos - ctx.pos;
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "table-of-contents",
-          data: {
-            attributes: {},
-            align,
-          },
-        },
-      ],
-      consumed,
-    };
-  },
-};

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

@@ -1,154 +0,0 @@
-/**
- *
- * Parses the Wikidot named anchor syntax: `[[# name]]`.
- *
- * A named anchor creates an invisible anchor target (`<a id="name">`)
- * that can be referenced by page-internal links such as `[#name Label]`
- * or triple-bracket anchor links like `[[[#name]]]`.
- *
- * The anchor name must consist exclusively of the characters
- * `[-_A-Za-z0-9.%]` (matching the original Wikidot regex
- * `/(\[\[# )([-_A-Za-z0-9.%]+?)(\]\])/i`).
- *
- * A whitespace gap is required between the `#` and the name
- * (`[[# myAnchor]]` is valid; `[[#myAnchor]]` is not).
- *
- * Produces an `"anchor-name"` AST element whose `data` field contains
- * the raw anchor name string.
- *
- * @module
- */
-import type { Element } from "@wdprlib/ast";
-import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-
-/**
- * Tests whether a single character is a valid anchor name character.
- *
- * Wikidot restricts anchor names to ASCII alphanumerics, hyphens,
- * underscores, dots, and percent signs.
- *
- * @param char - A single character to validate
- * @returns `true` if the character is allowed in an anchor name
- */
-function isValidAnchorChar(char: string): boolean {
-  return /^[-_A-Za-z0-9.%]$/.test(char);
-}
-
-/**
- * Inline rule for parsing `[[# name]]` named anchor targets.
- *
- * Triggered by a `BLOCK_OPEN` (`[[`) token. The rule looks for the `#`
- * character followed by mandatory whitespace and then the anchor name.
- *
- * Parsing steps:
- * 1. Consume `[[` and optional leading whitespace
- * 2. Require a `#` token (HASH or TEXT `"#"`)
- * 3. Require at least one whitespace token after `#`
- * 4. Collect consecutive valid anchor-name characters as the name
- * 5. Require closing `]]`
- *
- * Fails if the anchor name is empty or if `]]` is not found.
- */
-export const anchorNameRule: InlineRule = {
-  name: "anchorName",
-  startTokens: ["BLOCK_OPEN"],
-
-  /**
-   * Attempts to parse a `[[# name]]` named anchor at the current position.
-   *
-   * @param ctx - Parse context with token stream and current position
-   * @returns A successful result with an `"anchor-name"` element, or `{ success: 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;
-
-    // Skip whitespace
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-
-    // Check for # (hash) - can be TEXT or HASH token
-    const hashToken = ctx.tokens[pos];
-    if (
-      !hashToken ||
-      (hashToken.type !== "HASH" && !(hashToken.type === "TEXT" && hashToken.value === "#"))
-    ) {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    // Require whitespace after #
-    if (ctx.tokens[pos]?.type !== "WHITESPACE") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    // Skip additional whitespace
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-
-    // Parse anchor name - collect valid characters until ]]
-    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;
-      }
-      // Check if all characters in token are valid anchor chars
-      const value = token.value;
-      let allValid = true;
-      for (const char of value) {
-        if (!isValidAnchorChar(char)) {
-          allValid = false;
-          break;
-        }
-      }
-      if (!allValid) {
-        break;
-      }
-      name += value;
-      pos++;
-      consumed++;
-    }
-
-    // Anchor name is required
-    if (!name) {
-      return { success: false };
-    }
-
-    // Expect ]]
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "anchor-name",
-          data: name,
-        },
-      ],
-      consumed,
-    };
-  },
-};