@wdprlib/parser 3.1.2 → 4.0.0

package/src/parser/rules/block/block-list/item-content.ts

@@ -0,0 +1,132 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { getCandidateInlineRules } from "../../inline/utils";
+import { getCandidateBlockRules } from "../utils";
+import { isLiOpen, isListClose, isNestedListOpen, type ListBlockType } from "./tags";
+
+interface ListItemContentResult {
+  matched: boolean;
+  elements: Element[];
+  consumed: number;
+}
+
+const blockListExcludedRulesCache = new WeakMap<
+  ParseContext["blockRules"],
+  ParseContext["blockRules"]
+>();
+
+export function parseListItemBlockContent(
+  ctx: ParseContext,
+  pos: number,
+  token: ParseContext["tokens"][number],
+): ListItemContentResult {
+  const blockCtx: ParseContext = { ...ctx, pos };
+  const filteredBlockRules = getBlockListExcludedRules(ctx.blockRules);
+
+  for (const rule of getCandidateBlockRules(filteredBlockRules, token)) {
+    const result = rule.parse(blockCtx);
+    if (result.success) {
+      return { matched: true, elements: result.elements, consumed: result.consumed };
+    }
+  }
+
+  return { matched: false, elements: [], consumed: 0 };
+}
+
+function getBlockListExcludedRules(
+  blockRules: ParseContext["blockRules"],
+): ParseContext["blockRules"] {
+  const cached = blockListExcludedRulesCache.get(blockRules);
+  if (cached) {
+    return cached;
+  }
+
+  const filtered = blockRules.filter((rule) => rule.name !== "block-list");
+  blockListExcludedRulesCache.set(blockRules, filtered);
+  return filtered;
+}
+
+export function parseListItemInlineContent(
+  ctx: ParseContext,
+  pos: number,
+  tokenType: ParseContext["tokens"][number]["type"],
+): ListItemContentResult {
+  const inlineCtx: ParseContext = { ...ctx, pos };
+
+  for (const rule of getCandidateInlineRules(ctx.inlineRules, tokenType)) {
+    const result = rule.parse(inlineCtx);
+    if (result.success) {
+      return { matched: true, elements: result.elements, consumed: result.consumed };
+    }
+  }
+
+  return { matched: false, elements: [], consumed: 0 };
+}
+
+export function collectPostLiTrailingContent(
+  ctx: ParseContext,
+  startPos: number,
+  listType: ListBlockType,
+): { elements: Element[]; consumed: number } {
+  const elements: Element[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") break;
+
+    if (token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      while (ctx.tokens[pos]?.type === "NEWLINE") {
+        pos++;
+        consumed++;
+      }
+      while (ctx.tokens[pos]?.type === "WHITESPACE" && ctx.tokens[pos]?.lineStart) {
+        pos++;
+        consumed++;
+      }
+      if (isPostLiBoundary(ctx, pos, listType)) {
+        break;
+      }
+      continue;
+    }
+
+    if (isPostLiBoundary(ctx, pos, listType)) {
+      break;
+    }
+
+    const inlineResult = parseListItemInlineContent(ctx, pos, token.type);
+    if (inlineResult.matched) {
+      elements.push(...inlineResult.elements);
+      consumed += inlineResult.consumed;
+      pos += inlineResult.consumed;
+      continue;
+    }
+
+    elements.push({ element: "text", data: token.value });
+    consumed++;
+    pos++;
+  }
+
+  return { elements, consumed };
+}
+
+function isPostLiBoundary(ctx: ParseContext, pos: number, listType: ListBlockType): boolean {
+  return (
+    isLiOpen(ctx, pos) !== null ||
+    isListClose(ctx, pos, listType) ||
+    isNestedListOpen(ctx, pos) !== null ||
+    ctx.tokens[pos]?.type === "EOF"
+  );
+}

package/src/parser/rules/block/block-list/li-content.ts

@@ -0,0 +1,107 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseListItemBlockContent, parseListItemInlineContent } from "./item-content";
+import { isLiClose, isListClose, isNestedListOpen, type ListBlockType } from "./tags";
+
+export type NestedListParser = (
+  ctx: ParseContext,
+  startPos: number,
+  listType: ListBlockType,
+) => { element: Element; consumed: number } | null;
+
+export interface LiContentResult {
+  elements: Element[];
+  consumed: number;
+}
+
+export function collectLiItemContent(
+  ctx: ParseContext,
+  startPos: number,
+  listType: ListBlockType,
+  parseNestedList: NestedListParser,
+): LiContentResult {
+  const elements: Element[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") break;
+    if (isLiClose(ctx, pos) || isListClose(ctx, pos, listType)) break;
+
+    const nestedListOpen = isNestedListOpen(ctx, pos);
+    if (nestedListOpen) {
+      const nestedResult = parseNestedList(ctx, pos, nestedListOpen.type);
+      if (nestedResult) {
+        elements.push(nestedResult.element);
+        elements.push({ element: "line-break" });
+        consumed += nestedResult.consumed;
+        pos += nestedResult.consumed;
+        continue;
+      }
+    }
+
+    if (token.type === "WHITESPACE" && token.lineStart) {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    if (token.type === "NEWLINE") {
+      const newlineResult = consumeLiItemNewlines(ctx, pos, elements.length > 0);
+      if (newlineResult.addLineBreak) {
+        elements.push({ element: "line-break" });
+      }
+      pos += newlineResult.consumed;
+      consumed += newlineResult.consumed;
+      continue;
+    }
+
+    const blockResult = parseListItemBlockContent(ctx, pos, token);
+    if (blockResult.matched) {
+      elements.push(...blockResult.elements);
+      consumed += blockResult.consumed;
+      pos += blockResult.consumed;
+      continue;
+    }
+
+    const inlineResult = parseListItemInlineContent(ctx, pos, token.type);
+    if (inlineResult.matched) {
+      elements.push(...inlineResult.elements);
+      consumed += inlineResult.consumed;
+      pos += inlineResult.consumed;
+      continue;
+    }
+
+    elements.push({ element: "text", data: token.value });
+    consumed++;
+    pos++;
+  }
+
+  return { elements, consumed };
+}
+
+function consumeLiItemNewlines(
+  ctx: ParseContext,
+  startPos: number,
+  hasContent: boolean,
+): { consumed: number; addLineBreak: boolean } {
+  let pos = startPos + 1;
+  let consumed = 1;
+  let consecutiveNewlines = 1;
+
+  while (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+    consecutiveNewlines++;
+  }
+  while (ctx.tokens[pos]?.type === "WHITESPACE" && ctx.tokens[pos]?.lineStart) {
+    pos++;
+    consumed++;
+  }
+
+  return {
+    consumed,
+    addLineBreak: consecutiveNewlines === 1 && hasContent,
+  };
+}

package/src/parser/rules/block/block-list/li-item.ts

@@ -0,0 +1,77 @@
+import type { ListItem } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseAttributes } from "../utils";
+import { collectPostLiTrailingContent } from "./item-content";
+import { collectLiItemContent, type NestedListParser } from "./li-content";
+import { consumeCloseTag, isLiClose, isLiOpen, type ListBlockType } from "./tags";
+
+/**
+ * Parses a single `[[li]]...[[/li]]` list item, including its attributes
+ * and body content.
+ */
+export function parseLiItem(
+  ctx: ParseContext,
+  startPos: number,
+  listType: ListBlockType,
+  parseNestedList: NestedListParser,
+): { item: ListItem; consumed: number } | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  const liOpen = isLiOpen(ctx, pos);
+  if (!liOpen) return null;
+
+  pos += liOpen.consumed;
+  consumed += liOpen.consumed;
+
+  const attrResult = parseAttributes(ctx, pos);
+  pos += attrResult.consumed;
+  consumed += attrResult.consumed;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+
+  const contentResult = collectLiItemContent(ctx, pos, listType, parseNestedList);
+  const contentElements = contentResult.elements;
+  consumed += contentResult.consumed;
+  pos += contentResult.consumed;
+
+  if (!isLiClose(ctx, pos)) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: "Missing closing tag [[/li]] for [[li]]",
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 },
+      },
+    });
+  }
+
+  if (isLiClose(ctx, pos)) {
+    const closeConsumed = consumeCloseTag(ctx, pos);
+    consumed += closeConsumed;
+    pos += closeConsumed;
+
+    const trailingResult = collectPostLiTrailingContent(ctx, pos, listType);
+    contentElements.push(...trailingResult.elements);
+    consumed += trailingResult.consumed;
+  }
+
+  return {
+    item: {
+      "item-type": "elements",
+      attributes: attrResult.attrs,
+      elements: contentElements,
+    },
+    consumed,
+  };
+}

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

@@ -0,0 +1,100 @@
+import type { Element, ListData, ListItem } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBareListContent } from "./bare-content";
+import { parseLiItem } from "./li-item";
+import { parseListBlockOpen } from "./open";
+import { consumeCloseTag, isListClose, isNestedListOpen, type ListBlockType } from "./tags";
+
+/**
+ * Parses a complete `[[ul]]...[[/ul]]` or `[[ol]]...[[/ol]]` block.
+ */
+export function parseListBlock(
+  ctx: ParseContext,
+  startPos: number,
+  listType: ListBlockType,
+): { element: Element; consumed: number } | null {
+  const openResult = parseListBlockOpen(ctx, startPos);
+  if (!openResult || openResult.listType !== listType) {
+    return null;
+  }
+
+  let pos = openResult.pos;
+  let consumed = openResult.consumed;
+
+  const items: ListItem[] = [];
+  let foundListClose = false;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") break;
+
+    if (isListClose(ctx, pos, listType)) {
+      foundListClose = true;
+      const closeConsumed = consumeCloseTag(ctx, pos);
+      consumed += closeConsumed;
+      break;
+    }
+
+    if (token.type === "WHITESPACE" || token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    const nestedListOpen = isNestedListOpen(ctx, pos);
+    if (nestedListOpen) {
+      const nestedResult = parseListBlock(ctx, pos, nestedListOpen.type);
+      if (nestedResult && nestedResult.element.element === "list") {
+        items.push({
+          "item-type": "sub-list",
+          element: "list",
+          data: nestedResult.element.data,
+        });
+        consumed += nestedResult.consumed;
+        pos += nestedResult.consumed;
+        continue;
+      }
+    }
+
+    const liResult = parseLiItem(ctx, pos, listType, parseListBlock);
+    if (liResult) {
+      items.push(liResult.item);
+      consumed += liResult.consumed;
+      pos += liResult.consumed;
+      continue;
+    }
+
+    const bareResult = parseBareListContent(ctx, pos, listType);
+    if (bareResult.item) {
+      items.push(bareResult.item);
+    }
+    consumed += bareResult.consumed;
+    pos += bareResult.consumed;
+  }
+
+  if (!foundListClose) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: `Missing closing tag [[/${listType}]] for [[${listType}]]`,
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 },
+      },
+    });
+  }
+
+  const listData: ListData = {
+    type: listType === "ol" ? "numbered" : "bullet",
+    attributes: openResult.attrs,
+    items,
+  };
+
+  return {
+    element: {
+      element: "list",
+      data: listData,
+    },
+    consumed,
+  };
+}

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

@@ -0,0 +1,51 @@
+import type { ParseContext } from "../../types";
+import { parseAttributes, parseBlockName } from "../utils";
+import { isListBlockType, type ListBlockType } from "./tags";
+
+export interface ListBlockOpenResult {
+  listType: ListBlockType;
+  attrs: Record<string, string>;
+  pos: number;
+  consumed: number;
+}
+
+export function parseListBlockOpen(
+  ctx: ParseContext,
+  startPos: number,
+): ListBlockOpenResult | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") return null;
+  pos++;
+  consumed++;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult || !isListBlockType(nameResult.name)) {
+    return null;
+  }
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  const attrResult = parseAttributes(ctx, pos);
+  pos += attrResult.consumed;
+  consumed += attrResult.consumed;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+
+  return {
+    listType: nameResult.name,
+    attrs: attrResult.attrs,
+    pos,
+    consumed,
+  };
+}

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

@@ -0,0 +1,50 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+
+export type ListBlockType = "ul" | "ol";
+
+export function isListBlockType(name: string): name is ListBlockType {
+  return name === "ul" || name === "ol";
+}
+
+export function isListClose(ctx: ParseContext, pos: number, expectedType?: ListBlockType): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return false;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult) return false;
+  return expectedType ? nameResult.name === expectedType : isListBlockType(nameResult.name);
+}
+
+export function isLiClose(ctx: ParseContext, pos: number): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return false;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  return nameResult?.name === "li";
+}
+
+export function isLiOpen(
+  ctx: ParseContext,
+  pos: number,
+): { name: string; consumed: number } | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult || nameResult.name !== "li") return null;
+  return { name: nameResult.name, consumed: 1 + nameResult.consumed };
+}
+
+export function isNestedListOpen(
+  ctx: ParseContext,
+  pos: number,
+): { type: ListBlockType; consumed: number } | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult || !isListBlockType(nameResult.name)) return null;
+  return { type: nameResult.name, consumed: 1 + nameResult.consumed };
+}
+
+export function consumeCloseTag(ctx: ParseContext, pos: number): number {
+  let closeConsumed = 1;
+  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;
+}

package/src/parser/rules/block/blockquote/build.ts

@@ -0,0 +1,62 @@
+import type { Element } from "@wdprlib/ast";
+import { processDepths, type DepthList } from "../../../depth";
+import type { BlockquoteLine, ParsedBlockquoteLine } from "./lines";
+
+export function buildBlockquoteElements(lines: ParsedBlockquoteLine[]): Element[] {
+  const depthTrees = processDepths<null, BlockquoteLine>(null, lines);
+  return depthTrees.map(({ list }) => buildBlockquoteElement(list));
+}
+
+function buildBlockquoteElement(list: DepthList<null, BlockquoteLine>): Element {
+  const children: Element[] = [];
+  let currentParagraphChildren: Element[] = [];
+
+  function flushParagraph() {
+    if (currentParagraphChildren.length > 0) {
+      while (
+        currentParagraphChildren.length > 0 &&
+        currentParagraphChildren[currentParagraphChildren.length - 1]?.element === "line-break"
+      ) {
+        currentParagraphChildren.pop();
+      }
+      if (currentParagraphChildren.length > 0) {
+        children.push({
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {},
+            elements: currentParagraphChildren,
+          },
+        });
+      }
+      currentParagraphChildren = [];
+    }
+  }
+
+  for (const item of list) {
+    if (item.kind === "item") {
+      if (item.value.elements.length === 0) {
+        flushParagraph();
+        continue;
+      }
+      currentParagraphChildren.push(...item.value.elements);
+      if (item.value.hasLineBreak) {
+        currentParagraphChildren.push({ element: "line-break" });
+      }
+    } else {
+      flushParagraph();
+      children.push(buildBlockquoteElement(item.children));
+    }
+  }
+
+  flushParagraph();
+
+  return {
+    element: "container",
+    data: {
+      type: "blockquote",
+      attributes: {},
+      elements: children,
+    },
+  };
+}

package/src/parser/rules/block/blockquote/index.ts

@@ -0,0 +1,80 @@
+/**
+ *
+ * Block rule for Wikidot-style blockquotes using `>` markers.
+ *
+ * Wikidot blockquotes are written with one or more `>` characters at the
+ * start of a line, followed by a mandatory space and then the content:
+ *
+ * ```
+ * > First level
+ * >> Second level
+ * > Back to first
+ * ```
+ *
+ * Key behaviours:
+ * - The depth is determined by the number of consecutive `>` characters.
+ * - A space after the `>` markers is required; lines like `>No space` are
+ *   consumed but silently discarded from output.
+ * - An empty line (just `> `) within the same depth acts as a paragraph
+ *   separator inside the blockquote.
+ * - Nesting is handled by the generic {@link processDepths} utility, which
+ *   converts flat depth-annotated rows into a recursive tree structure.
+ * - Maximum depth is capped at `MAX_BLOCKQUOTE_DEPTH` (30) to guard
+ *   against pathological input.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { buildBlockquoteElements, collectBlockquoteLines } from "./lines";
+
+/**
+ * Block rule for `>` prefix blockquotes.
+ *
+ * Parsing strategy:
+ * 1. Collect consecutive lines that begin with BLOCKQUOTE_MARKER at line start.
+ * 2. For each line, record the depth (number of `>` chars, zero-indexed)
+ *    and parse the inline content after the mandatory space.
+ * 3. Lines missing the required space are consumed but produce no output.
+ * 4. Feed the flat depth list into {@link processDepths} to build a nested tree.
+ * 5. Recursively convert the tree into nested blockquote container elements
+ *    via `buildBlockquoteElement()`.
+ */
+export const blockquoteRule: BlockRule = {
+  name: "blockquote",
+  startTokens: ["BLOCKQUOTE_MARKER"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const firstToken = currentToken(ctx);
+
+    if (!firstToken.lineStart) {
+      return { success: false };
+    }
+
+    const blockquoteLines = collectBlockquoteLines(ctx);
+
+    // No rows parsed
+    if (blockquoteLines.lines.length === 0) {
+      // If we consumed tokens (e.g. lines without space after >), return empty success
+      if (blockquoteLines.consumed > 0) {
+        return { success: true, elements: [], consumed: blockquoteLines.consumed };
+      }
+      return { success: false };
+    }
+
+    const blockquotes = buildBlockquoteElements(blockquoteLines.lines);
+
+    // Return first blockquote (should usually be only one)
+    if (blockquotes.length === 0) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: blockquotes,
+      consumed: blockquoteLines.consumed,
+    };
+  },
+};