@wdprlib/parser 3.2.0 → 4.1.0

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.ts → strikethrough/index.ts}

@@ -19,48 +19,9 @@
  * @module
  */
 import type { Element } from "@wdprlib/ast";
-import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { parseInlineUntil } from "./utils";
-
-/**
- * Validates whether the current position contains a valid strikethrough
- * pair (opening and closing `--` markers).
- *
- * Scans from the token after the opening marker to find a closing
- * `STRIKE_MARKER`. The strikethrough is invalid if:
- * - No closing marker is found before a newline or EOF
- * - The closing marker is preceded by a whitespace token
- *
- * The whitespace restriction exists because Wikidot distinguishes
- * `--text--` (strikethrough) from `-- text --` (em-dashes).
- *
- * @param ctx - Parse context positioned at the opening `--` marker
- * @returns `true` if a valid strikethrough pair is found
- */
-function isValidStrikethrough(ctx: ParseContext): boolean {
-  let pos = ctx.pos + 1; // Start after opening marker
-  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") {
-      // Found closing marker
-      // Invalid if preceded by whitespace
-      if (prevWasWhitespace) {
-        return false;
-      }
-      return true;
-    }
-
-    prevWasWhitespace = token.type === "WHITESPACE";
-    pos++;
-  }
-  return false;
-}
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { parseStrikethroughContent } from "./parse";
+import { hasValidStrikethroughClose } from "./syntax";
 
 /**
  * Inline rule for parsing `--strikethrough--` formatting or converting
@@ -85,7 +46,7 @@ export const strikethroughRule: InlineRule = {
    */
   parse(ctx: ParseContext): RuleResult<Element> {
     // Check if valid strikethrough (no whitespace before closing --)
-    if (!isValidStrikethrough(ctx)) {
+    if (!hasValidStrikethroughClose(ctx)) {
       // Not valid strikethrough, convert to em-dash
       return {
         success: true,
@@ -94,22 +55,6 @@ export const strikethroughRule: InlineRule = {
       };
     }
 
-    // Parse content between markers
-    const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "STRIKE_MARKER");
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "strikethrough",
-            attributes: {},
-            elements: result.elements,
-          },
-        },
-      ],
-      consumed: 1 + result.consumed + 1, // open + content + close
-    };
+    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

@@ -17,8 +17,7 @@
  */
 import type { Element } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { currentToken, hasClosingMarkerBeforeNewline } from "../types";
-import { parseInlineUntil } from "./utils";
+import { parseSameLineDelimitedContainer } from "./formatting/container";
 
 /**
  * Inline rule for parsing `,,subscript,,` formatting.
@@ -43,42 +42,6 @@ export const subscriptRule: InlineRule = {
    *          text fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    const startToken = currentToken(ctx);
-
-    // Check if closing marker exists
-    if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "SUB_MARKER")) {
-      return {
-        success: true,
-        elements: [{ element: "text", data: startToken.value }],
-        consumed: 1,
-      };
-    }
-
-    // Parse content between markers
-    const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "SUB_MARKER");
-
-    // Empty subscript (,,,,) is ignored in Wikidot
-    if (result.elements.length === 0) {
-      return {
-        success: true,
-        elements: [],
-        consumed: 1 + result.consumed + 1,
-      };
-    }
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "subscript",
-            attributes: {},
-            elements: result.elements,
-          },
-        },
-      ],
-      consumed: 1 + result.consumed + 1,
-    };
+    return parseSameLineDelimitedContainer(ctx, "SUB_MARKER", "subscript", { discardEmpty: true });
   },
 };

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

@@ -17,8 +17,7 @@
  */
 import type { Element } from "@wdprlib/ast";
 import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { currentToken, hasClosingMarkerBeforeNewline } from "../types";
-import { parseInlineUntil } from "./utils";
+import { parseSameLineDelimitedContainer } from "./formatting/container";
 
 /**
  * Inline rule for parsing `^^superscript^^` formatting.
@@ -43,42 +42,8 @@ export const superscriptRule: InlineRule = {
    *          text fallback for unmatched markers
    */
   parse(ctx: ParseContext): RuleResult<Element> {
-    const startToken = currentToken(ctx);
-
-    // Check if closing marker exists
-    if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "SUPER_MARKER")) {
-      return {
-        success: true,
-        elements: [{ element: "text", data: startToken.value }],
-        consumed: 1,
-      };
-    }
-
-    // Parse content between markers
-    const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "SUPER_MARKER");
-
-    // Empty superscript (^^^^) is ignored in Wikidot
-    if (result.elements.length === 0) {
-      return {
-        success: true,
-        elements: [],
-        consumed: 1 + result.consumed + 1,
-      };
-    }
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "superscript",
-            attributes: {},
-            elements: result.elements,
-          },
-        },
-      ],
-      consumed: 1 + result.consumed + 1,
-    };
+    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 };
+}

package/src/parser/rules/inline/{text.ts → text/index.ts}

@@ -19,8 +19,9 @@
  * @module
  */
 import type { Element } from "@wdprlib/ast";
-import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { textElement } from "./element";
 
 /**
  * Inline rule for plain text and whitespace tokens.
@@ -46,7 +47,7 @@ export const textRule: InlineRule = {
 
     return {
       success: true,
-      elements: [{ element: "text", data: token.value }],
+      elements: [textElement(token.value)],
       consumed: 1,
     };
   },
@@ -77,7 +78,7 @@ export const fallbackRule: InlineRule = {
 
     return {
       success: true,
-      elements: [{ element: "text", data: token.value }],
+      elements: [textElement(token.value)],
       consumed: 1,
     };
   },

package/src/parser/rules/inline/underline/child.ts

@@ -0,0 +1,26 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseInlineUntil } from "../utils";
+
+export interface UnderlineChildResult {
+  elements: Element[];
+  consumed: number;
+}
+
+export function parseUnderlineChild(ctx: ParseContext, pos: number): UnderlineChildResult {
+  const token = ctx.tokens[pos];
+  if (!token) {
+    return { elements: [], consumed: 0 };
+  }
+
+  if (token.type === "NEWLINE") {
+    return { elements: [{ element: "line-break" }], consumed: 1 };
+  }
+
+  const result = parseInlineUntil({ ...ctx, pos }, "UNDERLINE_MARKER");
+  if (result.elements.length > 0) {
+    return { elements: result.elements, consumed: result.consumed };
+  }
+
+  return { elements: [{ element: "text", data: token.value }], consumed: 1 };
+}

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

@@ -0,0 +1,29 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseUnderlineChild } from "./child";
+
+export function parseUnderlineContent(
+  ctx: ParseContext,
+  startPos: number,
+): { children: Element[]; consumed: number } {
+  const children: Element[] = [];
+  let pos = startPos;
+  let consumed = 1;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") break;
+
+    if (token.type === "UNDERLINE_MARKER") {
+      consumed++;
+      break;
+    }
+
+    const child = parseUnderlineChild(ctx, pos);
+    children.push(...child.elements);
+    pos += child.consumed;
+    consumed += child.consumed;
+  }
+
+  return { children, consumed };
+}