@wdprlib/parser 3.1.2 → 4.0.0

package/src/parser/rules/inline/size/value.ts

@@ -0,0 +1,45 @@
+import type { ParseContext } from "../../types";
+
+const VALID_SIZE_UNITS = ["px", "em", "rem", "ex", "%", "cm", "mm", "in", "pc"];
+
+export function parseSizeValue(
+  ctx: ParseContext,
+  startPos: number,
+): { size: string; consumed: number } | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const parts: string[] = [];
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "BLOCK_CLOSE" ||
+      token.type === "NEWLINE" ||
+      token.type === "EOF" ||
+      token.type === "WHITESPACE"
+    ) {
+      break;
+    }
+    parts.push(token.value);
+    pos++;
+    consumed++;
+  }
+
+  if (parts.length === 0) {
+    return null;
+  }
+
+  const size = parts.join("");
+  return isValidSizeValue(size) ? { size, consumed } : null;
+}
+
+function isValidSizeValue(size: string): boolean {
+  const unitPattern = VALID_SIZE_UNITS.join("|");
+  return new RegExp(`^(\\d+(?:\\.\\d+)?)(${unitPattern})$`, "i").test(size);
+}

package/src/parser/rules/inline/span/content.ts

@@ -0,0 +1,97 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { inlineRules } from "../../index";
+import { getCandidateInlineRules } from "../utils";
+import { consumeSpanNewline } from "./newline";
+import { parseCloseSpan } from "./syntax";
+import type { SpanBlockName } from "./syntax";
+
+export interface SpanContent {
+  children: Element[];
+  escapedChildren: Element[];
+  splitSpans: Element[][];
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function parseSpanContent(
+  ctx: ParseContext,
+  startPos: number,
+  blockName: SpanBlockName,
+): SpanContent {
+  const paragraphStrip = blockName === "span_";
+  const children: Element[] = [];
+  const escapedChildren: Element[] = [];
+  const splitSpans: Element[][] = [];
+  let foundClose = false;
+  let afterBlankLine = false;
+  let consumed = 0;
+  let pos = startPos;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    const close = parseCloseSpan(ctx, pos);
+    if (close.success) {
+      pos += close.consumed;
+      consumed += close.consumed;
+      foundClose = true;
+      break;
+    }
+
+    if (token.type === "NEWLINE") {
+      const newline = consumeSpanNewline(
+        ctx,
+        pos,
+        paragraphStrip,
+        afterBlankLine,
+        children,
+        escapedChildren,
+        splitSpans,
+      );
+      pos += newline.consumed;
+      consumed += newline.consumed;
+      afterBlankLine = afterBlankLine || newline.afterBlankLine;
+      continue;
+    }
+
+    if (token.type === "WHITESPACE" && token.lineStart) {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    const targetChildren = afterBlankLine ? escapedChildren : children;
+    const parsed = parseOneSpanChild(ctx, pos, targetChildren);
+    pos += parsed.consumed;
+    consumed += parsed.consumed;
+  }
+
+  return { children, escapedChildren, splitSpans, consumed, foundClose };
+}
+
+function parseOneSpanChild(
+  ctx: ParseContext,
+  pos: number,
+  targetChildren: Element[],
+): { consumed: number } {
+  const token = ctx.tokens[pos];
+  if (!token) {
+    return { consumed: 0 };
+  }
+
+  const inlineCtx: ParseContext = { ...ctx, pos };
+  for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
+    const result = rule.parse(inlineCtx);
+    if (result.success) {
+      targetChildren.push(...result.elements);
+      return { consumed: result.consumed };
+    }
+  }
+
+  targetChildren.push({ element: "text", data: token.value });
+  return { consumed: 1 };
+}

package/src/parser/rules/inline/span/elements.ts

@@ -0,0 +1,108 @@
+import type { Element } from "@wdprlib/ast";
+import type { SpanContent } from "./content";
+import type { SpanBlockName } from "./syntax";
+
+export function buildSpanElements(
+  blockName: SpanBlockName,
+  attributes: Record<string, string>,
+  content: SpanContent,
+): Element[] {
+  if (blockName === "span_") {
+    return buildParagraphStripSpans(attributes, content.children, content.escapedChildren);
+  }
+
+  if (content.splitSpans.length > 0) {
+    return buildSplitSpans(attributes, content.children, content.splitSpans);
+  }
+
+  return [
+    {
+      element: "container",
+      data: {
+        type: "span",
+        attributes,
+        elements: content.children,
+      },
+    },
+  ];
+}
+
+function buildParagraphStripSpans(
+  attributes: Record<string, string>,
+  children: Element[],
+  escapedChildren: Element[],
+): Element[] {
+  trimEdgeLineBreaks(children);
+  trimEdgeLineBreaks(escapedChildren);
+
+  const elements: Element[] = [];
+
+  if (children.length > 0) {
+    elements.push({
+      element: "container",
+      data: {
+        type: "span",
+        attributes,
+        elements: children,
+        _paragraphStrip: true,
+      },
+    });
+  }
+
+  if (escapedChildren.length > 0) {
+    elements.push({
+      element: "container",
+      data: {
+        type: "span",
+        attributes: {},
+        elements: escapedChildren,
+        _escapedFromParagraph: true,
+      },
+    });
+  }
+
+  if (elements.length === 0) {
+    return [
+      {
+        element: "container",
+        data: {
+          type: "span",
+          attributes: {},
+          elements: [],
+          _emptyParagraphStrip: true,
+        },
+      },
+    ];
+  }
+
+  return elements;
+}
+
+function buildSplitSpans(
+  attributes: Record<string, string>,
+  children: Element[],
+  splitSpans: Element[][],
+): Element[] {
+  if (children.length > 0) {
+    splitSpans.push(children);
+  }
+
+  return splitSpans.map((segment, index) => ({
+    element: "container" as const,
+    data: {
+      type: "span" as const,
+      attributes: index === 0 ? attributes : {},
+      elements: segment,
+      _splitByBlankLine: index > 0,
+    },
+  }));
+}
+
+function trimEdgeLineBreaks(elements: Element[]): void {
+  while (elements.length > 0 && elements[0]?.element === "line-break") {
+    elements.shift();
+  }
+  while (elements.length > 0 && elements[elements.length - 1]?.element === "line-break") {
+    elements.pop();
+  }
+}

package/src/parser/rules/inline/span/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Inline rules for `[[span]]` and orphaned `[[/span]]`.
+ *
+ * @module
+ */
+
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { buildSpanElements } from "./elements";
+import { parseCloseSpan, parseSpanOpener } from "./syntax";
+import { parseSpanContent } from "./content";
+
+export const spanRule: InlineRule = {
+  name: "span",
+  startTokens: ["BLOCK_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const opener = parseSpanOpener(ctx);
+    if (!opener.success) {
+      return { success: false };
+    }
+
+    const content = parseSpanContent(ctx, opener.pos, opener.blockName);
+    if (!content.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/span]] for [[${opener.blockName}]]`,
+        position: openToken.position,
+      });
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: buildSpanElements(opener.blockName, opener.attributes, content),
+      consumed: opener.consumed + content.consumed,
+    };
+  },
+};
+
+export const closeSpanRule: InlineRule = {
+  name: "closeSpan",
+  startTokens: ["BLOCK_END_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const token = currentToken(ctx);
+    if (token.type !== "BLOCK_END_OPEN") {
+      return { success: false };
+    }
+
+    const close = parseCloseSpan(ctx, ctx.pos);
+    if (!close.success) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "container",
+          data: {
+            type: "span",
+            attributes: {},
+            elements: [],
+            _closeSpan: true,
+          },
+        },
+      ],
+      consumed: close.consumed,
+    };
+  },
+};

package/src/parser/rules/inline/span/newline.ts

@@ -0,0 +1,50 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+
+export interface SpanNewlineResult {
+  consumed: number;
+  afterBlankLine: boolean;
+}
+
+export function consumeSpanNewline(
+  ctx: ParseContext,
+  pos: number,
+  paragraphStrip: boolean,
+  afterBlankLine: boolean,
+  children: Element[],
+  escapedChildren: Element[],
+  splitSpans: Element[][],
+): SpanNewlineResult {
+  let lookAhead = 1;
+  while (ctx.tokens[pos + lookAhead]?.type === "WHITESPACE") {
+    lookAhead++;
+  }
+  const nextToken = ctx.tokens[pos + lookAhead];
+
+  if (nextToken?.type === "NEWLINE") {
+    if (!paragraphStrip && children.length > 0) {
+      splitSpans.push([...children]);
+      children.length = 0;
+    }
+
+    let consumed = 1;
+    let nextPos = pos + 1;
+    while (ctx.tokens[nextPos]?.type === "WHITESPACE" || ctx.tokens[nextPos]?.type === "NEWLINE") {
+      nextPos++;
+      consumed++;
+    }
+
+    return { consumed, afterBlankLine: paragraphStrip };
+  }
+
+  const targetChildren = paragraphStrip && afterBlankLine ? escapedChildren : children;
+  targetChildren.push({ element: "line-break" });
+  let consumed = 1;
+  let nextPos = pos + 1;
+  while (ctx.tokens[nextPos]?.type === "WHITESPACE" && ctx.tokens[nextPos]?.lineStart) {
+    nextPos++;
+    consumed++;
+  }
+
+  return { consumed, afterBlankLine: false };
+}

package/src/parser/rules/inline/span/syntax.ts

@@ -0,0 +1,70 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../../common";
+import { parseAttributes } from "../../block/utils";
+
+export type SpanBlockName = "span" | "span_";
+
+export type SpanOpenerResult =
+  | {
+      success: true;
+      blockName: SpanBlockName;
+      attributes: Record<string, string>;
+      pos: number;
+      consumed: number;
+    }
+  | { success: false };
+
+export type CloseSpanResult = { success: true; consumed: number } | { success: false };
+
+export function parseSpanOpener(ctx: ParseContext): SpanOpenerResult {
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult || (nameResult.name !== "span" && nameResult.name !== "span_")) {
+    return { success: false };
+  }
+
+  const blockName = nameResult.name;
+  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 { success: false };
+  }
+  pos++;
+  consumed++;
+
+  return {
+    success: true,
+    blockName,
+    attributes: attrResult.attrs,
+    pos,
+    consumed,
+  };
+}
+
+export function parseCloseSpan(ctx: ParseContext, startPos: number): CloseSpanResult {
+  const token = ctx.tokens[startPos];
+  if (token?.type !== "BLOCK_END_OPEN") {
+    return { success: false };
+  }
+
+  const nameResult = parseBlockName(ctx, startPos + 1);
+  if (!nameResult || nameResult.name !== "span") {
+    return { success: false };
+  }
+
+  let pos = startPos + 1 + nameResult.consumed;
+  let consumed = 1 + nameResult.consumed;
+
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    consumed++;
+  }
+
+  return { success: true, consumed };
+}

package/src/parser/rules/inline/strikethrough/index.ts

@@ -0,0 +1,60 @@
+/**
+ *
+ * Parses the Wikidot strikethrough formatting syntax: `--text--`.
+ *
+ * Strikethrough text is delimited by double hyphens. However, the `--`
+ * token has dual meaning in Wikidot: it can be either a strikethrough
+ * marker or an em-dash. The disambiguation rule is:
+ *
+ * - If a matching closing `--` is found on the same line AND the closing
+ *   marker is NOT preceded by whitespace, it is treated as strikethrough.
+ * - Otherwise, the `--` is converted to an em-dash character (U+2014).
+ *
+ * This means `--word--` produces strikethrough, but `-- word --` produces
+ * two em-dashes with "word" between them.
+ *
+ * Produces a `"container"` AST element with `type: "strikethrough"`,
+ * or a `"text"` element containing the em-dash character.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { parseStrikethroughContent } from "./parse";
+import { hasValidStrikethroughClose } from "./syntax";
+
+/**
+ * Inline rule for parsing `--strikethrough--` formatting or converting
+ * `--` to an em-dash.
+ *
+ * Triggered by a `STRIKE_MARKER` token (`--`). First validates whether
+ * a proper strikethrough pair exists. If yes, parses the content
+ * between markers as strikethrough. If no, converts the `--` to an
+ * em-dash character (U+2014).
+ */
+export const strikethroughRule: InlineRule = {
+  name: "strikethrough",
+  startTokens: ["STRIKE_MARKER"],
+
+  /**
+   * Attempts to parse strikethrough formatting or produce an em-dash.
+   *
+   * @param ctx - Parse context with token stream and current position
+   * @returns A successful result with either a `"container"` element of
+   *          type `"strikethrough"`, or a `"text"` element containing
+   *          the em-dash character
+   */
+  parse(ctx: ParseContext): RuleResult<Element> {
+    // Check if valid strikethrough (no whitespace before closing --)
+    if (!hasValidStrikethroughClose(ctx)) {
+      // Not valid strikethrough, convert to em-dash
+      return {
+        success: true,
+        elements: [{ element: "text", data: "\u2014" }], // em-dash
+        consumed: 1,
+      };
+    }
+
+    return parseStrikethroughContent(ctx);
+  },
+};

package/src/parser/rules/inline/strikethrough/parse.ts

@@ -0,0 +1,14 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext, RuleResult } from "../../types";
+import { createInlineContainer } from "../formatting/container";
+import { parseInlineUntil } from "../utils";
+
+export function parseStrikethroughContent(ctx: ParseContext): RuleResult<Element> {
+  const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "STRIKE_MARKER");
+
+  return {
+    success: true,
+    elements: [createInlineContainer("strikethrough", result.elements)],
+    consumed: 1 + result.consumed + 1,
+  };
+}

package/src/parser/rules/inline/strikethrough/syntax.ts

@@ -0,0 +1,24 @@
+import type { ParseContext } from "../../types";
+
+/**
+ * Returns true when the current `--` can be parsed as strikethrough.
+ */
+export function hasValidStrikethroughClose(ctx: ParseContext): boolean {
+  let pos = ctx.pos + 1;
+  let prevWasWhitespace = false;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
+      return false;
+    }
+
+    if (token.type === "STRIKE_MARKER") {
+      return !prevWasWhitespace;
+    }
+
+    prevWasWhitespace = token.type === "WHITESPACE";
+    pos++;
+  }
+  return false;
+}

package/src/parser/rules/inline/subscript.ts

@@ -0,0 +1,47 @@
+/**
+ *
+ * Parses the Wikidot subscript formatting syntax: `,,text,,`.
+ *
+ * Subscript text is delimited by double commas. The opening and closing
+ * markers must appear on the same line. If no closing `,,` is found
+ * before a newline, the opening marker is emitted as literal text.
+ *
+ * Empty subscript (`,,,,`) is silently discarded by Wikidot (produces
+ * no output), matching the behavior of bold and superscript.
+ *
+ * Renders as a `<sub>` element in HTML.
+ *
+ * Produces a `"container"` AST element with `type: "subscript"`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../types";
+import { parseSameLineDelimitedContainer } from "./formatting/container";
+
+/**
+ * Inline rule for parsing `,,subscript,,` formatting.
+ *
+ * Triggered by a `SUB_MARKER` token (`,,`). Checks for a matching
+ * closing marker on the same line, then recursively parses inline
+ * content between the markers.
+ *
+ * When no closing marker is found, the opening `,,` is treated as
+ * literal text.
+ */
+export const subscriptRule: InlineRule = {
+  name: "subscript",
+  startTokens: ["SUB_MARKER"],
+
+  /**
+   * Attempts to parse subscript formatting at the current position.
+   *
+   * @param ctx - Parse context with token stream and current position
+   * @returns A successful result containing either a `"container"` element
+   *          with `type: "subscript"`, an empty array (for `,,,,`), or a
+   *          text fallback for unmatched markers
+   */
+  parse(ctx: ParseContext): RuleResult<Element> {
+    return parseSameLineDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
+  },
+};

package/src/parser/rules/inline/superscript.ts

@@ -0,0 +1,49 @@
+/**
+ *
+ * Parses the Wikidot superscript formatting syntax: `^^text^^`.
+ *
+ * Superscript text is delimited by double carets. The opening and
+ * closing markers must appear on the same line. If no closing `^^`
+ * is found before a newline, the opening marker is emitted as literal text.
+ *
+ * Empty superscript (`^^^^`) is silently discarded by Wikidot (produces
+ * no output), matching the behavior of bold and subscript.
+ *
+ * Renders as a `<sup>` element in HTML.
+ *
+ * Produces a `"container"` AST element with `type: "superscript"`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../types";
+import { parseSameLineDelimitedContainer } from "./formatting/container";
+
+/**
+ * Inline rule for parsing `^^superscript^^` formatting.
+ *
+ * Triggered by a `SUPER_MARKER` token (`^^`). Checks for a matching
+ * closing marker on the same line, then recursively parses inline
+ * content between the markers.
+ *
+ * When no closing marker is found, the opening `^^` is treated as
+ * literal text.
+ */
+export const superscriptRule: InlineRule = {
+  name: "superscript",
+  startTokens: ["SUPER_MARKER"],
+
+  /**
+   * Attempts to parse superscript formatting at the current position.
+   *
+   * @param ctx - Parse context with token stream and current position
+   * @returns A successful result containing either a `"container"` element
+   *          with `type: "superscript"`, an empty array (for `^^^^`), or a
+   *          text fallback for unmatched markers
+   */
+  parse(ctx: ParseContext): RuleResult<Element> {
+    return parseSameLineDelimitedContainer(ctx, "SUPER_MARKER", "superscript", {
+      discardEmpty: true,
+    });
+  },
+};

package/src/parser/rules/inline/text/element.ts

@@ -0,0 +1,5 @@
+import type { Element } from "@wdprlib/ast";
+
+export function textElement(data: string): Element {
+  return { element: "text", data };
+}