@wdprlib/parser 3.2.0 → 4.1.0

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

@@ -1,337 +0,0 @@
-/**
- * Block rule for Wikidot collapsible blocks: `[[collapsible]]...[[/collapsible]]`.
- *
- * A collapsible renders as a show/hide toggle with body content that can
- * be expanded or collapsed. The opening tag accepts several attributes
- * (which may span multiple lines):
- *
- * - `show`           -- label text for the "show" link (default: "+ show block").
- * - `hide`           -- label text for the "hide" link (default: "- hide block").
- * - `folded`         -- when `"no"`, the block starts in the expanded state.
- * - `hideLocation`   -- where the toggle link appears: `"top"` (default),
- *                       `"bottom"`, `"both"`, or `"neither"`/`"none"`.
- *
- * Key Wikidot-specific behaviours:
- * - Collapsibles cannot nest. When the body parser encounters a second
- *   `[[collapsible]]`, it is treated as plain text. This is achieved by
- *   filtering the collapsible rule out of the block rule list for body parsing.
- * - Orphaned `[[/collapsible]]` tags after the matched close are consumed and
- *   emitted as `<br />` + literal text, matching Wikidot rendering.
- * - An inline form (`[[collapsible]]text[[/collapsible]]` on one line) is
- *   supported but uncommon.
- *
- * @module
- */
-import type { Element } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseBlockName, parseBlocksUntil } from "./utils";
-
-/**
- * Parses block attributes that may be spread across multiple lines.
- *
- * Unlike the standard {@link parseAttributes}, this variant allows NEWLINE
- * tokens between attribute pairs, which Wikidot permits for `[[collapsible]]`
- * tags with many attributes.
- *
- * @param ctx      - Parse context.
- * @param startPos - Token index to start scanning.
- * @returns Parsed key/value pairs and the number of tokens consumed.
- */
-function parseMultilineAttributes(
-  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 === "EOF") {
-      break;
-    }
-
-    if (token.type === "WHITESPACE" || token.type === "NEWLINE") {
-      pos++;
-      consumed++;
-      continue;
-    }
-
-    if (token.type === "TEXT" || token.type === "IDENTIFIER") {
-      let name = token.value;
-      pos++;
-      consumed++;
-
-      // Handle hyphenated names (e.g. "hide-location")
-      while (
-        ctx.tokens[pos]?.type === "TEXT" &&
-        ctx.tokens[pos]?.value === "-" &&
-        (ctx.tokens[pos + 1]?.type === "IDENTIFIER" || ctx.tokens[pos + 1]?.type === "TEXT")
-      ) {
-        name += "-";
-        pos++;
-        consumed++;
-        name += ctx.tokens[pos]?.value ?? "";
-        pos++;
-        consumed++;
-      }
-
-      const eqToken = ctx.tokens[pos];
-      if (eqToken?.type === "EQUALS") {
-        pos++;
-        consumed++;
-        const valueToken = ctx.tokens[pos];
-        if (valueToken?.type === "QUOTED_STRING") {
-          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 {
-        attrs[name] = "true";
-      }
-    } else {
-      // Unknown token type in attribute context, stop
-      break;
-    }
-  }
-
-  return { attrs, consumed };
-}
-
-/**
- * Tests whether the tokens at `pos` form a `[[/collapsible]]` closing tag.
- *
- * @param ctx - Parse context.
- * @param pos - Token index to inspect.
- * @returns `true` if the closing tag is found.
- */
-function isCollapsibleClose(ctx: ParseContext, pos: number): boolean {
-  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return false;
-  const nameResult = parseBlockName(ctx, pos + 1);
-  return nameResult?.name === "collapsible";
-}
-
-/**
- * Counts the number of tokens occupied by the `[[/collapsible]]` closing
- * tag, including the optional trailing NEWLINE.
- *
- * @param ctx - Parse context.
- * @param pos - Token index at the BLOCK_END_OPEN.
- * @returns Total token count of the closing tag.
- */
-function consumeCloseTag(ctx: ParseContext, pos: number): number {
-  let closeConsumed = 1; // BLOCK_END_OPEN
-  const nameResult = parseBlockName(ctx, pos + 1);
-  if (nameResult) closeConsumed += nameResult.consumed;
-  if (ctx.tokens[pos + closeConsumed]?.type === "BLOCK_CLOSE") closeConsumed++;
-  if (ctx.tokens[pos + closeConsumed]?.type === "NEWLINE") closeConsumed++;
-  return closeConsumed;
-}
-
-/** Block names excluded from rule dispatch and paragraph-boundary detection. */
-const EXCLUDED_BLOCKS = new Set(["collapsible"]);
-
-/**
- * Block rule for `[[collapsible ...]]...[[/collapsible]]`.
- *
- * Parsing strategy:
- * 1. Match BLOCK_OPEN + name "collapsible".
- * 2. Parse multiline attributes (show, hide, folded, hideLocation, etc.).
- * 3. If a NEWLINE follows the opening tag, parse body as block content
- *    with the collapsible rule itself excluded (to prevent nesting).
- *    Otherwise, parse inline content until close tag or end of line
- *    (inline form).
- * 4. Consume the `[[/collapsible]]` closing tag.
- * 5. Consume any orphaned `[[/collapsible]]` tags that follow, converting
- *    them to `<br />` + literal text.
- * 6. Derive `show-top` / `show-bottom` booleans from the `hideLocation`
- *    attribute.
- */
-export const collapsibleRule: BlockRule = {
-  name: "collapsible",
-  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;
-
-    const nameResult = parseBlockName(ctx, pos);
-    if (!nameResult || nameResult.name !== "collapsible") {
-      return { success: false };
-    }
-
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
-
-    const attrResult = parseMultilineAttributes(ctx, pos);
-    pos += attrResult.consumed;
-    consumed += attrResult.consumed;
-
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
-      return { success: false };
-    }
-    pos++;
-    consumed++;
-
-    // Record opening tag position for diagnostics
-    const openPosition = openToken.position;
-
-    const hasNewlineAfterOpen = ctx.tokens[pos]?.type === "NEWLINE";
-    if (hasNewlineAfterOpen) {
-      pos++;
-      consumed++;
-    }
-
-    let bodyElements: Element[];
-
-    if (
-      !hasNewlineAfterOpen &&
-      ctx.tokens[pos]?.type !== "EOF" &&
-      ctx.tokens[pos]?.type !== "BLOCK_END_OPEN"
-    ) {
-      // Inline form: [[collapsible]]content[[/collapsible]] on same line
-      // Parse inline content until [[/collapsible]] or NEWLINE
-      const inlineElements: Element[] = [];
-      let inlineConsumed = 0;
-      let inlinePos = pos;
-
-      while (inlinePos < ctx.tokens.length) {
-        const token = ctx.tokens[inlinePos];
-        if (!token || token.type === "EOF" || token.type === "NEWLINE") break;
-        if (isCollapsibleClose(ctx, inlinePos)) break;
-        inlineElements.push({ element: "text", data: token.value });
-        inlinePos++;
-        inlineConsumed++;
-      }
-
-      consumed += inlineConsumed;
-      pos += inlineConsumed;
-
-      if (inlineElements.length > 0) {
-        bodyElements = [
-          {
-            element: "container",
-            data: {
-              type: "paragraph",
-              attributes: {},
-              elements: inlineElements,
-            },
-          },
-        ];
-      } else {
-        bodyElements = [];
-      }
-    } else {
-      // Block form: parse content recursively until [[/collapsible]]
-      // Collapsible cannot be nested in Wikidot - nested [[collapsible]] becomes plain text.
-      // excludedBlockNames removes the collapsible rule from dispatch AND prevents
-      // [[collapsible]] / [[/collapsible]] tokens from triggering paragraph splits.
-      const bodyCtx: ParseContext = { ...ctx, pos };
-
-      const closeCondition = (checkCtx: ParseContext): boolean => {
-        return isCollapsibleClose(checkCtx, checkCtx.pos);
-      };
-
-      const bodyResult = parseBlocksUntil(bodyCtx, closeCondition, {
-        excludedBlockNames: EXCLUDED_BLOCKS,
-      });
-      consumed += bodyResult.consumed;
-      pos += bodyResult.consumed;
-
-      bodyElements = bodyResult.elements;
-    }
-
-    // Check for missing close tag
-    if (!isCollapsibleClose(ctx, pos)) {
-      ctx.diagnostics.push({
-        severity: "warning",
-        code: "unclosed-block",
-        message: "Missing closing tag [[/collapsible]] for [[collapsible]]",
-        position: openPosition,
-      });
-    }
-
-    // Consume [[/collapsible]]
-    if (isCollapsibleClose(ctx, pos)) {
-      const closeConsumed = consumeCloseTag(ctx, pos);
-      consumed += closeConsumed;
-      pos += closeConsumed;
-    }
-
-    // Consume orphaned [[/collapsible]] after the block
-    // Wikidot renders these as bare <br />[[/collapsible]] (no <p> wrapper)
-    const orphanedElements: Element[] = [];
-    while (isCollapsibleClose(ctx, pos)) {
-      orphanedElements.push({ element: "line-break" });
-
-      // Convert tokens of [[/collapsible]] to text
-      while (pos < ctx.tokens.length) {
-        const t = ctx.tokens[pos];
-        if (!t || t.type === "NEWLINE" || t.type === "EOF") break;
-        orphanedElements.push({ element: "text", data: t.value });
-        consumed++;
-        pos++;
-      }
-
-      // Skip trailing NEWLINE
-      if (ctx.tokens[pos]?.type === "NEWLINE") {
-        consumed++;
-        pos++;
-      }
-    }
-
-    // Determine show-top/show-bottom from hideLocation attribute
-    const hideLocation = (
-      attrResult.attrs.hideLocation ??
-      attrResult.attrs.hidelocation ??
-      "top"
-    ).toLowerCase();
-    let showTop = true;
-    let showBottom = false;
-    if (hideLocation === "both") {
-      showTop = true;
-      showBottom = true;
-    } else if (hideLocation === "bottom") {
-      showTop = false;
-      showBottom = true;
-    } else if (hideLocation === "neither" || hideLocation === "none") {
-      showTop = false;
-      showBottom = false;
-    }
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "collapsible",
-          data: {
-            elements: bodyElements,
-            attributes: {},
-            "start-open": attrResult.attrs.folded === "no",
-            "show-text": attrResult.attrs.show ?? null,
-            "hide-text": attrResult.attrs.hide ?? null,
-            "show-top": showTop,
-            "show-bottom": showBottom,
-          },
-        },
-        ...orphanedElements,
-      ],
-      consumed,
-    };
-  },
-};

package/src/parser/rules/block/definition-list.ts

@@ -1,270 +0,0 @@
-/**
- *
- * Block rule for Wikidot definition lists written with the `: key : value` syntax.
- *
- * Each item starts at the beginning of a line with a COLON, followed by
- * mandatory whitespace, the key (term), a second COLON, and then the value
- * (definition). Multiple consecutive items form a single `<dl>` block.
- *
- * ```
- * : Apple : A fruit that grows on trees.
- * : Banana : A yellow curved fruit.
- * ```
- *
- * Key parsing details:
- * - Whitespace after the first colon is required (`": key"` not `":key"`).
- * - The key portion supports inline markup (bold, links, etc.).
- * - The value continues until a double newline, a new definition entry, or
- *   the end of the document.
- * - A single newline within the value does NOT break the entry -- parsing
- *   continues on the next line.
- *
- * @module
- */
-import type { Element, DefinitionListItem } from "@wdprlib/ast";
-import type { BlockRule, ParseContext, RuleResult } from "../types";
-import { parseInlineUntil } from "../inline/utils";
-
-/**
- * Internal representation of one definition list item before conversion
- * to the AST's {@link DefinitionListItem} format.
- */
-interface ParsedDefinitionItem {
-  /** Raw string of the key, used for `key_string` in the AST. */
-  keyString: string;
-  /** Parsed inline elements representing the key / term. */
-  key: Element[];
-  /** Parsed inline elements representing the value / definition. */
-  value: Element[];
-}
-
-/**
- * Parses a single definition list entry of the form `: key : value`.
- *
- * The function expects `startPos` to point at a line-start COLON token.
- * It consumes the first colon, mandatory whitespace, key tokens up to
- * the second colon, then value tokens until one of the following:
- * - A double newline (paragraph break).
- * - A new entry (COLON at line start).
- * - End of input.
- *
- * The key is parsed for inline content using {@link parseInlineUntil}
- * (stopping at COLON), and the value uses the same utility (stopping at
- * NEWLINE).
- *
- * @param ctx      - Parse context.
- * @param startPos - Token index of the expected line-start COLON.
- * @returns The parsed item and token count, or `null` on failure.
- */
-function parseDefinitionItem(
-  ctx: ParseContext,
-  startPos: number,
-): { item: ParsedDefinitionItem; 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: ": key : value"
-  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 key tokens until second COLON
-  const keyTokens: string[] = [];
-  const keyNodes: Element[] = [];
-  let foundSecondColon = false;
-
-  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;
-    }
-
-    // Parse inline content for key
-    const inlineCtx: ParseContext = { ...ctx, pos };
-    const result = parseInlineUntil(inlineCtx, "COLON");
-    if (result.elements.length > 0) {
-      keyNodes.push(...result.elements);
-      // Collect raw key string
-      for (let i = 0; i < result.consumed; i++) {
-        const t = ctx.tokens[pos + i];
-        if (t) keyTokens.push(t.value);
-      }
-      pos += result.consumed;
-      consumed += result.consumed;
-    } else {
-      keyTokens.push(token.value);
-      pos++;
-      consumed++;
-    }
-  }
-
-  if (!foundSecondColon) {
-    return null;
-  }
-
-  // Skip whitespace after second colon
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-
-  // Parse value (rest of line, can continue with line breaks)
-  const valueNodes: Element[] = [];
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token || token.type === "EOF") {
-      break;
-    }
-
-    // Check for end of definition (double newline or new definition)
-    if (token.type === "NEWLINE") {
-      const nextToken = ctx.tokens[pos + 1];
-      // Look ahead for continuation with underscore line break
-      if (nextToken?.type === "COLON" && nextToken.lineStart) {
-        // New definition item starts
-        pos++;
-        consumed++;
-        break;
-      }
-      if (nextToken?.type === "NEWLINE" || !nextToken || nextToken.type === "EOF") {
-        // Double newline or end - stop
-        pos++;
-        consumed++;
-        break;
-      }
-      // Single newline - continue parsing (becomes line break)
-    }
-
-    // Parse inline content
-    const inlineCtx: ParseContext = { ...ctx, pos };
-    const result = parseInlineUntil(inlineCtx, "NEWLINE");
-    if (result.elements.length > 0) {
-      valueNodes.push(...result.elements);
-      pos += result.consumed;
-      consumed += result.consumed;
-    } else {
-      pos++;
-      consumed++;
-    }
-  }
-
-  // Remove trailing whitespace from key
-  const keyString = keyTokens.join("").trim();
-
-  // Remove trailing whitespace nodes from key
-  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 {
-    item: {
-      keyString,
-      key: keyNodes,
-      value: valueNodes,
-    },
-    consumed,
-  };
-}
-
-/**
- * Block rule for Wikidot definition lists (`: key : value`).
- *
- * Parsing strategy:
- * 1. Verify the first token is a line-start COLON.
- * 2. Repeatedly call `parseDefinitionItem()` to collect entries.
- * 3. Stop when the current token is no longer a line-start COLON (i.e.
- *    the definition list block has ended).
- * 4. Convert internal items into the AST {@link DefinitionListItem} format.
- * 5. Emit a single `definition-list` element.
- */
-export const definitionListRule: BlockRule = {
-  name: "definitionList",
-  startTokens: ["COLON"],
-  requiresLineStart: true,
-
-  parse(ctx: ParseContext): RuleResult<Element> {
-    const items: ParsedDefinitionItem[] = [];
-    let pos = ctx.pos;
-    let totalConsumed = 0;
-
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (!token || token.type === "EOF") {
-        break;
-      }
-
-      // Only parse lines starting with :
-      if (token.type !== "COLON" || !token.lineStart) {
-        break;
-      }
-
-      const result = parseDefinitionItem(ctx, pos);
-      if (!result) {
-        break;
-      }
-
-      items.push(result.item);
-      pos += result.consumed;
-      totalConsumed += result.consumed;
-
-      // Skip any whitespace between items
-      while (ctx.tokens[pos]?.type === "WHITESPACE") {
-        pos++;
-        totalConsumed++;
-      }
-    }
-
-    if (items.length === 0) {
-      return { success: false };
-    }
-
-    // Convert items to DefinitionListItem format
-    const definitionItems: DefinitionListItem[] = items.map((item) => ({
-      key_string: item.keyString,
-      key: item.key,
-      value: item.value,
-    }));
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "definition-list",
-          data: definitionItems,
-        },
-      ],
-      consumed: totalConsumed,
-    };
-  },
-};