@wdprlib/parser 3.2.0 → 4.0.0

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

@@ -1,200 +0,0 @@
-/**
- *
- * Block rule for the Wikidot footnote block: `[[footnoteblock]]`.
- *
- * This self-closing block tag marks the location in the page where all
- * collected footnotes (from `[[footnote]]...[[/footnote]]` inline markers)
- * should be rendered. It is analogous to a "footnotes section" placeholder.
- *
- * Optional attributes:
- * - `title` -- custom heading text for the footnotes section.
- * - `hide`  -- when `"true"` or `"yes"`, suppresses footnote rendering.
- *
- * Wikidot only honours the FIRST `[[footnoteblock]]` in a document;
- * subsequent occurrences are treated as plain text. The parser tracks
- * this via `ctx.scope.footnoteBlockParsed`, but note: that flag is per
- * spread copy of `ParseContext` (see {@link ScopeContext.footnoteBlockParsed}).
- * In practice the duplicate-rejection only fires for two top-level
- * `[[footnoteblock]]` tokens; siblings inside the same body or across
- * nested bodies both succeed today. The auto-append decision in
- * `Parser.parse` uses a post-parse AST walk, so it is unaffected.
- *
- * @module
- */
-import type { Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-
-/**
- * Parses key/value attributes from tokens (e.g. `title="Custom title"`).
- *
- * This is a local attribute parser specific to the footnoteblock rule.
- * It handles TEXT or IDENTIFIER names, optional `=` with quoted or
- * unquoted values, and boolean attributes (name without value).
- *
- * @param ctx      - Parse context.
- * @param startPos - Token index to start scanning.
- * @returns Parsed attribute map and the number of tokens consumed.
- */
-function parseAttributes(
-  ctx: ParseContext,
-  startPos: number,
-): { attrs: Record<string, string>; consumed: number } {
-  const attrs: Record<string, string> = {};
-  let pos = startPos;
-  let consumed = 0;
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (
-      !token ||
-      token.type === "BLOCK_CLOSE" ||
-      token.type === "NEWLINE" ||
-      token.type === "EOF"
-    ) {
-      break;
-    }
-
-    // Skip whitespace
-    if (token.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-      continue;
-    }
-
-    // Attribute name (TEXT or IDENTIFIER token)
-    if (token.type === "TEXT" || token.type === "IDENTIFIER") {
-      const name = token.value.toLowerCase();
-      pos++;
-      consumed++;
-
-      // Check for =
-      const eqToken = ctx.tokens[pos];
-      if (eqToken?.type === "EQUALS") {
-        pos++;
-        consumed++;
-
-        // Get value (quoted string or text)
-        const valueToken = ctx.tokens[pos];
-        if (valueToken?.type === "QUOTED_STRING") {
-          // Remove quotes
-          let value = valueToken.value;
-          if (value.startsWith('"') && value.endsWith('"')) {
-            value = value.slice(1, -1);
-          }
-          attrs[name] = value;
-          pos++;
-          consumed++;
-        } else if (valueToken?.type === "TEXT" || valueToken?.type === "IDENTIFIER") {
-          attrs[name] = valueToken.value;
-          pos++;
-          consumed++;
-        }
-      } else {
-        // Boolean attribute
-        attrs[name] = "true";
-      }
-    } else {
-      // Unknown token, skip
-      pos++;
-      consumed++;
-    }
-  }
-
-  return { attrs, consumed };
-}
-
-/**
- * Block rule for `[[footnoteblock]]`.
- *
- * Parsing strategy:
- * 1. Match BLOCK_OPEN + name "footnoteblock" (case-insensitive).
- * 2. Parse optional attributes (`title`, `hide`).
- * 3. Consume closing `]]`.
- * 4. If `ctx.scope.footnoteBlockParsed` is already `true` on the current
- *    `ParseContext` copy, fail. Because `parseBlocksUntil` spreads a
- *    fresh `ctx` per sibling rule, this only rejects a second
- *    `[[footnoteblock]]` that arrives via the parser's top-level
- *    dispatch loop in practice. See {@link ScopeContext.footnoteBlockParsed}.
- * 5. Replace `ctx.scope` with the flag set to `true` and emit a `footnote-block`
- *    element.
- */
-export const footnoteBlockRule: BlockRule = {
-  name: "footnoteBlock",
-  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 consumed = 1;
-
-    // Skip whitespace
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-
-    // Check for block name
-    const nameToken = ctx.tokens[pos];
-    if (!nameToken || (nameToken.type !== "TEXT" && nameToken.type !== "IDENTIFIER")) {
-      return { success: false };
-    }
-
-    const blockName = nameToken.value.toLowerCase();
-    if (blockName !== "footnoteblock") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    // Parse optional attributes (title="...")
-    const { attrs, consumed: attrConsumed } = parseAttributes(ctx, pos);
-    pos += attrConsumed;
-    consumed += attrConsumed;
-
-    // Expect ]]
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    // Reject a second `[[footnoteblock]]` that arrives on the same
-    // `ParseContext` copy (in practice: at the top level — siblings
-    // inside `parseBlocksUntil` each get a fresh spread). The flag
-    // lives in the immutable `scope` group, so the mutation is
-    // expressed as a scope replacement. The cross-scope duplicate-
-    // rejection is a separate, known limitation.
-    if (ctx.scope.footnoteBlockParsed) {
-      return { success: false };
-    }
-    ctx.scope = { ...ctx.scope, footnoteBlockParsed: true };
-
-    // Extract title and hide from attributes
-    const title = attrs.title !== undefined ? attrs.title : null;
-    const hide = attrs.hide === "true" || attrs.hide === "yes";
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "footnote-block",
-          data: {
-            title,
-            hide,
-          },
-        },
-      ],
-      consumed,
-    };
-  },
-};

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

@@ -1,142 +0,0 @@
-/**
- *
- * Block rule for Wikidot headings: `+ Heading` through `++++++ Heading`.
- *
- * Headings are written with one to six `+` characters at the start of a
- * line, followed by mandatory whitespace and then inline content:
- *
- * ```
- * + H1 heading
- * ++ H2 heading
- * +++ H3 heading
- * ```
- *
- * An optional `*` immediately after the `+` markers hides the heading
- * from the table of contents:
- *
- * ```
- * +* Hidden H1
- * ```
- *
- * Seven or more `+` characters are NOT valid headings in Wikidot and
- * the rule will fail, letting them fall through to paragraph parsing.
- *
- * Non-hidden headings are registered in `ctx.tocEntries` for later use
- * by the table-of-contents module.
- *
- * @module
- */
-import type { Element, HeadingLevel } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseInlineUntil } from "../inline/utils";
-
-/**
- * Block rule for Wikidot headings (`+ ` through `++++++ `).
- *
- * Produces a container element with `type: { header: { level, "has-toc" } }`.
- * The heading text is parsed for inline markup (bold, links, etc.).
- */
-export const headingRule: BlockRule = {
-  name: "heading",
-  startTokens: ["HEADING_MARKER"],
-  requiresLineStart: true,
-
-  parse(ctx: ParseContext): RuleResult<Element> {
-    const marker = currentToken(ctx);
-
-    if (!marker.lineStart) {
-      return { success: false };
-    }
-
-    // Wikidot requires whitespace after heading marker
-    // Check format: + (space)content OR +* (space)content
-    let pos = ctx.pos + 1;
-    let consumed = 1;
-    let hidden = false;
-
-    // Check for hidden marker (*) - must come immediately after + markers
-    if (ctx.tokens[pos]?.type === "STAR") {
-      hidden = true;
-      pos++;
-      consumed++;
-    }
-
-    // Whitespace is required after + or +*
-    if (ctx.tokens[pos]?.type !== "WHITESPACE") {
-      return { success: false };
-    }
-
-    // Wikidot only supports h1-h6 (1-6 plus signs). 7+ is not a heading.
-    if (marker.value.length > 6) {
-      return { success: false };
-    }
-    const depth = marker.value.length as 1 | 2 | 3 | 4 | 5 | 6;
-
-    // Skip whitespace
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
-
-    // Parse inline content until newline
-    const inlineCtx: ParseContext = { ...ctx, pos };
-    const inlineResult = parseInlineUntil(inlineCtx, "NEWLINE");
-    const children: Element[] = inlineResult.elements;
-    consumed += inlineResult.consumed;
-    pos += inlineResult.consumed;
-
-    // Consume newline
-    if (ctx.tokens[pos]?.type === "NEWLINE") {
-      consumed++;
-    }
-
-    // Store TOC entry (only non-hidden headings)
-    if (!hidden) {
-      const headingText = extractText(children);
-      ctx.tocEntries.push({ level: depth, text: headingText });
-    }
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: { header: { level: depth as HeadingLevel, "has-toc": !hidden } },
-            attributes: {},
-            elements: children,
-          },
-        },
-      ],
-      consumed,
-    };
-  },
-};
-
-/**
- * Recursively extracts the plain-text content from a tree of elements.
- *
- * Used to build the `text` field for table-of-contents entries. Only
- * `text` elements and containers with nested `elements` are traversed;
- * other element types (images, etc.) are ignored.
- *
- * @param elements - The heading's inline child elements.
- * @returns Concatenated plain text.
- */
-function extractText(elements: Element[]): string {
-  let text = "";
-  for (const el of elements) {
-    if (el.element === "text" && typeof el.data === "string") {
-      text += el.data;
-    } else if (
-      el.element === "container" &&
-      el.data &&
-      typeof el.data === "object" &&
-      "elements" in el.data
-    ) {
-      text += extractText(el.data.elements as Element[]);
-    }
-  }
-  return text;
-}

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

@@ -1,222 +0,0 @@
-/**
- *
- * Block rule for the Wikidot HTML block: `[[html]]...[[/html]]`.
- *
- * An HTML block embeds raw HTML that Wikidot renders inside a sandboxed
- * `<iframe>`. The content between the tags is captured verbatim (no inline
- * parsing) and stored as an `html` element in the AST.
- *
- * Supported attributes on the opening tag:
- * - `style` -- applied to the containing iframe. Other attributes are
- *   parsed but only `style` is used by Wikidot's renderer.
- *
- * The raw content is also pushed into `ctx.htmlBlocks` for document-level
- * enumeration.
- *
- * If no `[[/html]]` closing tag is found, the rule fails and the opening
- * tag falls through to text rendering (matching Wikidot behaviour).
- *
- * @module
- */
-import type { Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseBlockName, parseAttributesRaw } from "./utils";
-
-/**
- * Scan forward from `from` to see whether a real `[[/html]]` close tag
- * exists later in the token stream. Used by the disabled path to decide
- * whether the blank-line stop should fire.
- *
- * Recognises whitespace between the name and the closing `]]` so the
- * answer matches what the main consume loop would actually accept.
- */
-export function lookaheadHasHtmlClose(ctx: ParseContext, from: number): boolean {
-  for (let i = from; i < ctx.tokens.length; i++) {
-    const t = ctx.tokens[i];
-    if (!t || t.type === "EOF") return false;
-    if (t.type !== "BLOCK_END_OPEN") continue;
-    const closeName = parseBlockName(ctx, i + 1);
-    if (closeName?.name.toLowerCase() !== "html") continue;
-    let cp = i + 1 + closeName.consumed;
-    while (ctx.tokens[cp]?.type === "WHITESPACE") cp++;
-    if (ctx.tokens[cp]?.type === "BLOCK_CLOSE") return true;
-  }
-  return false;
-}
-
-/**
- * Block rule for `[[html]]...[[/html]]`.
- *
- * Body content is stored as raw text. The optional `style` attribute is
- * passed through to the AST element for iframe styling.
- */
-export const htmlBlockRule: BlockRule = {
-  name: "html",
-  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.toLowerCase() !== "html") {
-      return { success: false };
-    }
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
-
-    // Parse attributes (type="css", style="...", etc.)
-    // Only style attribute is used by Wikidot (applied to iframe)
-    const attrResult = parseAttributesRaw(ctx, pos);
-    pos += attrResult.consumed;
-    consumed += attrResult.consumed;
-    const style = attrResult.attrs.style;
-
-    // Expect ]]
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    // Settings-level gate: when `[[html]]` is disabled, still consume the
-    // entire block so the raw body cannot leak as text, but produce no
-    // AST element and skip the `ctx.htmlBlocks` push. The malformed
-    // opener path above (missing `]]`) is intentionally not affected —
-    // it falls through to text rendering as before.
-    const disabled = ctx.settings.allowHtmlBlocks === false;
-
-    // When disabled, the blank-line stop must only kick in if no real
-    // `[[/html]]` exists later in the stream. A closed block legitimately
-    // contains blank lines between paragraphs.
-    const hasCloseAhead = disabled && lookaheadHasHtmlClose(ctx, pos);
-
-    // Collect HTML content until [[/html]]. When disabled, the body is
-    // discarded so accumulation is skipped entirely to avoid building a
-    // large string only to drop it.
-    let contents = "";
-    let foundClose = false;
-
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (!token || token.type === "EOF") break;
-
-      // When disabled with no close ahead, stop at a blank line so the
-      // rule does not swallow subsequent paragraphs.
-      if (
-        disabled &&
-        !hasCloseAhead &&
-        token.type === "NEWLINE" &&
-        ctx.tokens[pos + 1]?.type === "NEWLINE"
-      ) {
-        break;
-      }
-
-      // Check for closing [[/html]] — require the trailing `]]` so a
-      // malformed `[[/html` without its close does not falsely terminate
-      // the body and leak the rest as text.
-      if (token.type === "BLOCK_END_OPEN") {
-        const closeNameResult = parseBlockName(ctx, pos + 1);
-        if (closeNameResult?.name.toLowerCase() === "html") {
-          let checkPos = pos + 1 + closeNameResult.consumed;
-          while (ctx.tokens[checkPos]?.type === "WHITESPACE") checkPos++;
-          if (ctx.tokens[checkPos]?.type === "BLOCK_CLOSE") {
-            foundClose = true;
-            break;
-          }
-        }
-      }
-
-      if (!disabled) {
-        contents += token.value;
-      }
-      pos++;
-      consumed++;
-    }
-
-    // If no closing tag found:
-    //  - enabled: fail (matches Wikidot fallback to text)
-    //  - disabled: still consume to EOF so the body cannot leak, but emit
-    //    both the unclosed warning and the disabled-info diagnostics.
-    if (!foundClose) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: "Missing closing tag [[/html]] for [[html]]",
-        position: openToken.position,
-      });
-      if (!disabled) {
-        return { success: false };
-      }
-      ctx.diagnostics.push({
-        severity: "info",
-        code: "html-block-disabled",
-        message: "[[html]] block ignored: disabled by settings",
-        position: openToken.position,
-      });
-      return { success: true, elements: [], consumed };
-    }
-
-    // Consume [[/html]] (skipping any whitespace between name and `]]`
-    // to match the close-detection above).
-    if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
-      pos++;
-      consumed++;
-      const closeNameResult = parseBlockName(ctx, pos);
-      if (closeNameResult) {
-        pos += closeNameResult.consumed;
-        consumed += closeNameResult.consumed;
-      }
-      while (ctx.tokens[pos]?.type === "WHITESPACE") {
-        pos++;
-        consumed++;
-      }
-      if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
-        pos++;
-        consumed++;
-      }
-      if (ctx.tokens[pos]?.type === "NEWLINE") {
-        pos++;
-        consumed++;
-      }
-    }
-
-    if (disabled) {
-      ctx.diagnostics.push({
-        severity: "info",
-        code: "html-block-disabled",
-        message: "[[html]] block ignored: disabled by settings",
-        position: openToken.position,
-      });
-      return { success: true, elements: [], consumed };
-    }
-
-    // Trim the contents
-    contents = contents.trim();
-
-    // Store html block in context
-    ctx.htmlBlocks.push(contents);
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "html",
-          data: {
-            contents,
-            ...(style && { style }),
-          },
-        },
-      ],
-      consumed,
-    };
-  },
-};