@wdprlib/parser 3.2.0 → 4.0.0

package/src/parser/rules/inline/html/gate.ts

@@ -0,0 +1,64 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../../common";
+import { lookaheadHasHtmlClose } from "../../block/html";
+
+export interface DisabledHtmlBody {
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function consumeDisabledHtmlBody(ctx: ParseContext, startPos: number): DisabledHtmlBody {
+  const hasCloseAhead = lookaheadHasHtmlClose(ctx, startPos);
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    if (!hasCloseAhead && token.type === "NEWLINE" && ctx.tokens[pos + 1]?.type === "NEWLINE") {
+      break;
+    }
+
+    const closeResult = tryConsumeHtmlClose(ctx, pos);
+    if (closeResult) {
+      return {
+        consumed: consumed + closeResult.consumed,
+        foundClose: true,
+      };
+    }
+
+    pos++;
+    consumed++;
+  }
+
+  return { consumed, foundClose: false };
+}
+
+function tryConsumeHtmlClose(ctx: ParseContext, pos: number): { consumed: number } | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    return null;
+  }
+
+  const closeNameResult = parseBlockName(ctx, pos + 1);
+  if (closeNameResult?.name.toLowerCase() !== "html") {
+    return null;
+  }
+
+  let checkPos = pos + 1 + closeNameResult.consumed;
+  while (ctx.tokens[checkPos]?.type === "WHITESPACE") {
+    checkPos++;
+  }
+  if (ctx.tokens[checkPos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+
+  let consumed = checkPos - pos + 1;
+  if (ctx.tokens[checkPos + 1]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return { consumed };
+}

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

@@ -27,10 +27,10 @@
  */
 
 import type { Element } from "@wdprlib/ast";
-import type { InlineRule, ParseContext, RuleResult } from "../types";
-import { currentToken } from "../types";
-import { parseBlockName, parseAttributesRaw } from "../block/utils";
-import { lookaheadHasHtmlClose } from "../block/html";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { consumeDisabledHtmlBody } from "./gate";
+import { parseHtmlInlineOpen } from "./open";
 
 /**
  * Inline rule that gates `[[html]]` when the setting disallows it.
@@ -45,25 +45,10 @@ export const htmlInlineRule: InlineRule = {
       return { success: false };
     }
 
-    let pos = ctx.pos + 1;
-    let consumed = 1;
-
-    const nameResult = parseBlockName(ctx, pos);
-    if (!nameResult || nameResult.name.toLowerCase() !== "html") {
-      return { success: false };
-    }
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
-
-    const attrResult = parseAttributesRaw(ctx, pos);
-    pos += attrResult.consumed;
-    consumed += attrResult.consumed;
-
-    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    const openResult = parseHtmlInlineOpen(ctx);
+    if (!openResult) {
       return { success: false };
     }
-    pos++;
-    consumed++;
 
     // Enabled: leave inline `[[html]]` alone — it falls through to text
     // rendering, matching the historical behaviour for stray block-named
@@ -72,46 +57,10 @@ export const htmlInlineRule: InlineRule = {
       return { success: false };
     }
 
-    // Disabled path: consume the body until a real `[[/html]]` (BLOCK_END_OPEN
-    // + name + BLOCK_CLOSE, allowing whitespace inside the close tag).
-    // Only allow the blank-line stop when no real close exists ahead, so
-    // a closed body that spans paragraphs is still consumed correctly.
-    const hasCloseAhead = lookaheadHasHtmlClose(ctx, pos);
-    let foundClose = false;
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (!token || token.type === "EOF") break;
-
-      // Stop at a blank line so an unclosed inline `[[html]]` does not
-      // swallow subsequent paragraphs.
-      if (!hasCloseAhead && token.type === "NEWLINE" && ctx.tokens[pos + 1]?.type === "NEWLINE") {
-        break;
-      }
-
-      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;
-            // Consume `[[/html]]` (and optional trailing newline) too.
-            consumed += checkPos - pos + 1;
-            pos = checkPos + 1;
-            if (ctx.tokens[pos]?.type === "NEWLINE") {
-              pos++;
-              consumed++;
-            }
-            break;
-          }
-        }
-      }
-
-      pos++;
-      consumed++;
-    }
+    const bodyResult = consumeDisabledHtmlBody(ctx, openResult.bodyStart);
+    const consumed = openResult.consumed + bodyResult.consumed;
 
-    if (!foundClose) {
+    if (!bodyResult.foundClose) {
       ctx.diagnostics.push({
         severity: "warning",
         code: "unclosed-block",

package/src/parser/rules/inline/html/open.ts

@@ -0,0 +1,37 @@
+import type { ParseContext } from "../../types";
+import { parseAttributesRaw, parseBlockName } from "../../block/utils";
+
+export interface HtmlInlineOpenResult {
+  bodyStart: number;
+  consumed: number;
+}
+
+export function parseHtmlInlineOpen(ctx: ParseContext): HtmlInlineOpenResult | null {
+  if (ctx.tokens[ctx.pos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult || nameResult.name.toLowerCase() !== "html") {
+    return null;
+  }
+
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  const attrResult = parseAttributesRaw(ctx, pos);
+  pos += attrResult.consumed;
+  consumed += attrResult.consumed;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+
+  pos++;
+  consumed++;
+
+  return { bodyStart: pos, consumed };
+}

package/src/parser/rules/inline/image/attributes.ts

@@ -0,0 +1,22 @@
+import type { AttributeMap } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseAttributesRaw } from "../../block/utils";
+import { filterUnsafeAttributes } from "../../common";
+
+export interface ImageAttributes {
+  attributes: AttributeMap;
+  link: string | null;
+  consumed: number;
+}
+
+export function parseImageAttributes(ctx: ParseContext, startPos: number): ImageAttributes {
+  const result = parseAttributesRaw(ctx, startPos, false);
+  const link = result.attrs.link ?? null;
+  const { link: _link, ...htmlAttributes } = result.attrs;
+
+  return {
+    attributes: filterUnsafeAttributes(htmlAttributes),
+    link,
+    consumed: result.consumed,
+  };
+}

package/src/parser/rules/inline/image/body.ts

@@ -0,0 +1,36 @@
+import type { ParseContext } from "../../types";
+
+export interface ImageSourceText {
+  sourceText: string;
+  consumed: number;
+}
+
+export function parseImageSourceText(ctx: ParseContext, startPos: number): ImageSourceText {
+  let pos = startPos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  let sourceText = "";
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "WHITESPACE" ||
+      token.type === "BLOCK_CLOSE" ||
+      token.type === "NEWLINE" ||
+      token.type === "EOF"
+    ) {
+      break;
+    }
+
+    sourceText += token.value;
+    pos++;
+    consumed++;
+  }
+
+  return { sourceText, consumed };
+}

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

@@ -0,0 +1,89 @@
+/**
+ *
+ * Parses the Wikidot image block syntax: `[[image source attributes]]`.
+ *
+ * Images support several alignment/float prefixes that modify how the
+ * image is positioned on the page:
+ * - `[[image src]]` -- default (no alignment)
+ * - `[[=image src]]` -- centered
+ * - `[[<image src]]` -- left-aligned
+ * - `[[>image src]]` -- right-aligned
+ * - `[[f<image src]]` -- float left
+ * - `[[f>image src]]` -- float right
+ * - `[[f=image src]]` -- float center
+ *
+ * Image sources can be:
+ * - Full URLs (`http://...`, `https://...`, `/path`)
+ * - Local file references in three formats:
+ *   - `file.ext` (file on current page, type `file1`)
+ *   - `page/file.ext` (file on another page, type `file2`)
+ *   - `site:page/file.ext` or `site/page/file.ext` (cross-site file, type `file3`)
+ *
+ * Optional attributes follow the source (e.g. `alt`, `title`, `width`,
+ * `height`, `style`, `class`, `link`). The `link` attribute is treated
+ * specially: it wraps the image in a hyperlink rather than being applied
+ * as an HTML attribute. Unsafe attributes are filtered out.
+ *
+ * Produces an `"image"` AST element with source, alignment, link, and
+ * attribute data.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseImageOpen } from "./open";
+import { parseAlignment, parseImageSource } from "./source";
+
+/**
+ * Inline rule for parsing `[[image source attributes]]` and its alignment variants.
+ *
+ * Triggered by a `BLOCK_OPEN` (`[[`) token. The rule identifies the image
+ * block name (with optional alignment prefix), extracts the image source,
+ * parses remaining attributes, filters unsafe attributes, and extracts the
+ * `link` attribute for special handling.
+ *
+ * Fails if the block name is not an image variant, if no source is provided,
+ * or if `]]` is not found.
+ */
+export const imageRule: InlineRule = {
+  name: "image",
+  startTokens: ["BLOCK_OPEN"],
+
+  /**
+   * Attempts to parse an image block at the current position.
+   *
+   * @param ctx - Parse context with token stream and current position
+   * @returns A successful result with an `"image"` element, or `{ success: false }`
+   */
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const openResult = parseImageOpen(ctx);
+    if (!openResult) {
+      return { success: false };
+    }
+
+    const source = parseImageSource(openResult.sourceText);
+    const alignment = parseAlignment(openResult.blockName);
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "image",
+          data: {
+            source,
+            link: openResult.link,
+            alignment,
+            attributes: openResult.attributes,
+          },
+        },
+      ],
+      consumed: openResult.consumed,
+    };
+  },
+};

package/src/parser/rules/inline/image/open.ts

@@ -0,0 +1,56 @@
+import type { ParseContext } from "../../types";
+import { parseImageAttributes } from "./attributes";
+import { parseImageSourceText } from "./body";
+import { isImageBlockName, parseImageBlockName } from "./syntax";
+
+export interface ImageOpenResult {
+  blockName: string;
+  sourceText: string;
+  link: string | null;
+  attributes: Record<string, string>;
+  consumed: number;
+}
+
+export function parseImageOpen(ctx: ParseContext): ImageOpenResult | null {
+  if (ctx.tokens[ctx.pos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+
+  const nameResult = parseImageBlockName(ctx, pos);
+  if (!nameResult || !isImageBlockName(nameResult.name)) {
+    return null;
+  }
+
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  const sourceText = parseImageSourceText(ctx, pos);
+  pos += sourceText.consumed;
+  consumed += sourceText.consumed;
+
+  const attrs = parseImageAttributes(ctx, pos);
+  pos += attrs.consumed;
+  consumed += attrs.consumed;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+
+  pos++;
+  consumed++;
+
+  if (!sourceText.sourceText) {
+    return null;
+  }
+
+  return {
+    blockName: nameResult.name,
+    sourceText: sourceText.sourceText,
+    link: attrs.link,
+    attributes: attrs.attributes,
+    consumed,
+  };
+}

package/src/parser/rules/inline/image/source.ts

@@ -0,0 +1,62 @@
+import type { Alignment, FloatAlignment, ImageSource } from "@wdprlib/ast";
+
+export function parseImageSource(src: string): ImageSource {
+  if (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("/")) {
+    return { type: "url", data: src };
+  }
+
+  const colonIdx = src.indexOf(":");
+  const slashIdx = src.indexOf("/");
+
+  if (colonIdx > 0 && slashIdx > colonIdx) {
+    const site = src.substring(0, colonIdx);
+    const rest = src.substring(colonIdx + 1);
+    const lastSlash = rest.lastIndexOf("/");
+    const page = rest.substring(0, lastSlash);
+    const file = rest.substring(lastSlash + 1);
+    return { type: "file3", data: { site, page, file } };
+  }
+
+  const slashes = src.split("/").length - 1;
+  if (slashes >= 2) {
+    const firstSlash = src.indexOf("/");
+    const lastSlash = src.lastIndexOf("/");
+    const site = src.substring(0, firstSlash);
+    const page = src.substring(firstSlash + 1, lastSlash);
+    const file = src.substring(lastSlash + 1);
+    return { type: "file3", data: { site, page, file } };
+  }
+  if (slashIdx > 0) {
+    const page = src.substring(0, slashIdx);
+    const file = src.substring(slashIdx + 1);
+    return { type: "file2", data: { page, file } };
+  }
+
+  return { type: "file1", data: { file: src } };
+}
+
+export function parseAlignment(blockName: string): FloatAlignment | null {
+  let align: Alignment = "left";
+  let float = false;
+
+  if (blockName === "=image") {
+    align = "center";
+  } else if (blockName === "<image") {
+    align = "left";
+  } else if (blockName === ">image") {
+    align = "right";
+  } else if (blockName === "f<image") {
+    align = "left";
+    float = true;
+  } else if (blockName === "f>image") {
+    align = "right";
+    float = true;
+  } else if (blockName === "f=image") {
+    align = "center";
+    float = true;
+  } else if (blockName === "image") {
+    return null;
+  }
+
+  return { align, float };
+}

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

@@ -0,0 +1,76 @@
+import type { ParseContext } from "../../types";
+
+const IMAGE_BLOCK_NAMES = new Set([
+  "image",
+  "=image",
+  "<image",
+  ">image",
+  "f<image",
+  "f>image",
+  "f=image",
+]);
+
+export interface ImageBlockName {
+  name: string;
+  consumed: number;
+}
+
+export function parseImageBlockName(ctx: ParseContext, startPos: number): ImageBlockName | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const prefixResult = parseImagePrefix(ctx, pos);
+  const prefix = prefixResult.prefix;
+  pos += prefixResult.consumed;
+  consumed += prefixResult.consumed;
+
+  const nameToken = ctx.tokens[pos];
+  if (!nameToken || (nameToken.type !== "TEXT" && nameToken.type !== "IDENTIFIER")) {
+    return null;
+  }
+
+  return { name: prefix + nameToken.value.toLowerCase(), consumed: consumed + 1 };
+}
+
+export function isImageBlockName(blockName: string): boolean {
+  return IMAGE_BLOCK_NAMES.has(blockName);
+}
+
+function parseImagePrefix(ctx: ParseContext, pos: number): { prefix: string; consumed: number } {
+  const token = ctx.tokens[pos];
+
+  if (token?.type === "EQUALS") {
+    return { prefix: "=", consumed: 1 };
+  }
+  if (token?.type === "TEXT" && token.value === "<") {
+    return { prefix: "<", consumed: 1 };
+  }
+  if ((token?.type === "TEXT" || token?.type === "BLOCKQUOTE_MARKER") && token.value === ">") {
+    return { prefix: ">", consumed: 1 };
+  }
+  if (token?.type === "IDENTIFIER" && token.value.toLowerCase() === "f") {
+    return parseFloatPrefix(ctx, pos + 1);
+  }
+
+  return { prefix: "", consumed: 0 };
+}
+
+function parseFloatPrefix(ctx: ParseContext, pos: number): { prefix: string; consumed: number } {
+  const token = ctx.tokens[pos];
+  if (token?.type === "TEXT" && token.value === "<") {
+    return { prefix: "f<", consumed: 2 };
+  }
+  if ((token?.type === "TEXT" || token?.type === "BLOCKQUOTE_MARKER") && token.value === ">") {
+    return { prefix: "f>", consumed: 2 };
+  }
+  if (token?.type === "EQUALS") {
+    return { prefix: "f=", consumed: 2 };
+  }
+
+  return { prefix: "", consumed: 0 };
+}

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

@@ -18,8 +18,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 `//italic//` formatting.
@@ -42,33 +41,6 @@ export const italicRule: InlineRule = {
    *          with `type: "italics"`, or a 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 }, "ITALIC_MARKER")) {
-      return {
-        success: true,
-        elements: [{ element: "text", data: startToken.value }],
-        consumed: 1,
-      };
-    }
-
-    // Parse content between markers
-    const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "ITALIC_MARKER");
-
-    return {
-      success: true,
-      elements: [
-        {
-          element: "container",
-          data: {
-            type: "italics",
-            attributes: {},
-            elements: result.elements,
-          },
-        },
-      ],
-      consumed: 1 + result.consumed + 1, // open + content + close
-    };
+    return parseSameLineDelimitedContainer(ctx, "ITALIC_MARKER", "italics");
   },
 };

package/src/parser/rules/inline/line-break/backslash.ts

@@ -0,0 +1,58 @@
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { createPreservedLineBreak } from "./elements";
+
+export const backslashLineBreakRule: InlineRule = {
+  name: "backslashLineBreak",
+  startTokens: ["WHITESPACE", "BACKSLASH_BREAK"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const currentTok = ctx.tokens[ctx.pos];
+    if (!currentTok) {
+      return { success: false };
+    }
+
+    if (currentTok.type === "WHITESPACE") {
+      const nextTok = ctx.tokens[ctx.pos + 1];
+      if (nextTok?.type !== "BACKSLASH_BREAK") {
+        return { success: false };
+      }
+
+      if (isFollowedByUnderscoreBreak(ctx, ctx.pos + 2)) {
+        return {
+          success: true,
+          elements: [createPreservedLineBreak()],
+          consumed: 2,
+        };
+      }
+
+      return {
+        success: true,
+        elements: [createPreservedLineBreak(), { element: "text", data: " " }],
+        consumed: 2,
+      };
+    }
+
+    if (currentTok.type === "BACKSLASH_BREAK") {
+      return {
+        success: true,
+        elements: [createPreservedLineBreak()],
+        consumed: 1,
+      };
+    }
+
+    return { success: false };
+  },
+};
+
+function isFollowedByUnderscoreBreak(ctx: ParseContext, startPos: number): boolean {
+  const afterBreak = ctx.tokens[startPos];
+  const afterAfter = ctx.tokens[startPos + 1];
+  const afterAfterAfter = ctx.tokens[startPos + 2];
+
+  return (
+    afterBreak?.type === "WHITESPACE" &&
+    afterAfter?.type === "UNDERSCORE" &&
+    (afterAfterAfter?.type === "NEWLINE" || afterAfterAfter?.type === "EOF")
+  );
+}

package/src/parser/rules/inline/line-break/elements.ts

@@ -0,0 +1,9 @@
+import type { Element } from "@wdprlib/ast";
+
+export type PreservedLineBreak = Extract<Element, { element: "line-break" }> & {
+  _preservedTrailingBreak?: boolean;
+};
+
+export function createPreservedLineBreak(): PreservedLineBreak {
+  return { element: "line-break", _preservedTrailingBreak: true };
+}

package/src/parser/rules/inline/line-break/index.ts

@@ -0,0 +1,3 @@
+export { newlineLineBreakRule } from "./newline";
+export { backslashLineBreakRule } from "./backslash";
+export { underscoreLineBreakRule } from "./underscore";