@wdprlib/parser 3.1.2 → 4.0.0

package/src/parser/rules/block/iframe/attributes.ts

@@ -0,0 +1,106 @@
+import type { AttributeMap } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+
+/**
+ * Whitelist of attributes permitted on `[[iframe]]`. Wikidot strips
+ * `id` but permits `class`.
+ */
+const ALLOWED_IFRAME_ATTRS = new Set([
+  "align",
+  "class",
+  "frameborder",
+  "height",
+  "scrolling",
+  "style",
+  "width",
+]);
+
+export function parseIframeAttributes(
+  ctx: ParseContext,
+  startPos: number,
+): { attributes: AttributeMap; consumed: number } {
+  const attributes: AttributeMap = {};
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "BLOCK_CLOSE") break;
+
+    if (token.type === "NEWLINE") {
+      break;
+    }
+
+    if (token.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    if (token.type === "IDENTIFIER" || token.type === "TEXT") {
+      const key = token.value;
+      pos++;
+      consumed++;
+
+      while (ctx.tokens[pos]?.type === "WHITESPACE") {
+        pos++;
+        consumed++;
+      }
+
+      if (ctx.tokens[pos]?.type === "EQUALS") {
+        pos++;
+        consumed++;
+
+        while (ctx.tokens[pos]?.type === "WHITESPACE") {
+          pos++;
+          consumed++;
+        }
+
+        const valueResult = parseIframeAttributeValue(ctx, pos);
+        pos += valueResult.consumed;
+        consumed += valueResult.consumed;
+
+        const normalizedKey = key.toLowerCase();
+        if (ALLOWED_IFRAME_ATTRS.has(normalizedKey)) {
+          attributes[normalizedKey] = valueResult.value;
+        }
+      }
+    } else {
+      pos++;
+      consumed++;
+    }
+  }
+
+  return { attributes, consumed };
+}
+
+function parseIframeAttributeValue(
+  ctx: ParseContext,
+  startPos: number,
+): { value: string; consumed: number } {
+  const valueToken = ctx.tokens[startPos];
+  if (valueToken?.type === "QUOTED_STRING") {
+    return { value: valueToken.value.slice(1, -1), consumed: 1 };
+  }
+
+  let value = "";
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "BLOCK_CLOSE" ||
+      token.type === "WHITESPACE" ||
+      token.type === "NEWLINE"
+    ) {
+      break;
+    }
+    value += token.value;
+    pos++;
+    consumed++;
+  }
+
+  return { value, consumed };
+}

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

@@ -0,0 +1,73 @@
+/**
+ *
+ * Block rule for the Wikidot iframe block: `[[iframe URL attributes]]`.
+ *
+ * The `[[iframe]]` tag is a self-closing block that embeds an external
+ * page in an `<iframe>`. The first argument after the block name is the
+ * URL, followed by optional attributes.
+ *
+ * Security measures:
+ * - Only `http://` and `https://` URLs are accepted.
+ * - `javascript:`, `data:`, and `vbscript:` schemes are rejected.
+ * - URL normalisation strips whitespace and control characters to prevent
+ *   evasion via character insertion.
+ * - Only a specific set of HTML attributes is allowed (Wikidot filters
+ *   out `id` but permits `class`).
+ *
+ * Allowed attributes: `align`, `class`, `frameborder`, `height`,
+ * `scrolling`, `style`, `width`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseIframeOpen } from "./open";
+import { isAllowedIframeUrl } from "./url";
+
+/**
+ * Block rule for `[[iframe URL ...attributes]]`.
+ *
+ * Parsing strategy:
+ * 1. Match BLOCK_OPEN + name "iframe".
+ * 2. Consume the URL (all tokens until whitespace, BLOCK_CLOSE, or newline).
+ * 3. Validate the URL: normalise, reject dangerous schemes, require http(s).
+ * 4. Parse key/value attributes, filtering through `ALLOWED_IFRAME_ATTRS`.
+ * 5. Consume closing `]]` and optional trailing newline.
+ * 6. Emit an `iframe` element with `url` and `attributes`.
+ */
+export const iframeRule: BlockRule = {
+  name: "iframe",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const openResult = parseIframeOpen(ctx);
+    if (!openResult) {
+      return { success: false };
+    }
+
+    if (!isAllowedIframeUrl(openResult.url)) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "iframe",
+          data: {
+            url: openResult.url,
+            attributes: openResult.attributes,
+          },
+        },
+      ],
+      consumed: openResult.consumed,
+    };
+  },
+};

package/src/parser/rules/block/iframe/open.ts

@@ -0,0 +1,58 @@
+import type { AttributeMap } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+import { parseIframeAttributes } from "./attributes";
+import { parseIframeSource } from "./source";
+
+export interface IframeOpenResult {
+  url: string;
+  attributes: AttributeMap;
+  consumed: number;
+}
+
+export function parseIframeOpen(ctx: ParseContext): IframeOpenResult | 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() !== "iframe") {
+    return null;
+  }
+
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const sourceResult = parseIframeSource(ctx, pos);
+  if (!sourceResult) {
+    return null;
+  }
+
+  pos += sourceResult.consumed;
+  consumed += sourceResult.consumed;
+
+  const attrResult = parseIframeAttributes(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") {
+    consumed++;
+  }
+
+  return { url: sourceResult.url, attributes: attrResult.attributes, consumed };
+}

package/src/parser/rules/block/iframe/source.ts

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

package/src/parser/rules/block/iframe/url.ts

@@ -0,0 +1,38 @@
+/**
+ * Normalises a URL string for security checks by removing whitespace and
+ * control characters that could be used to evade scheme detection, then
+ * lowercasing the result.
+ */
+export function normalizeIframeUrl(url: string): string {
+  return stripControlAndWhitespace(url).toLowerCase();
+}
+
+const WHITESPACE = /\s/;
+
+function stripControlAndWhitespace(value: string): string {
+  let result = "";
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (WHITESPACE.test(char) || code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+
+/**
+ * Tests whether a normalised URL begins with a dangerous scheme that must
+ * be rejected.
+ */
+export function isDangerousIframeUrl(normalizedUrl: string): boolean {
+  return /^(javascript|data|vbscript):/i.test(normalizedUrl);
+}
+
+export function isAllowedIframeUrl(url: string): boolean {
+  const normalizedUrl = normalizeIframeUrl(url);
+  if (isDangerousIframeUrl(normalizedUrl)) {
+    return false;
+  }
+  return /^https?:\/\//i.test(normalizedUrl);
+}

package/src/parser/rules/block/iftags/body.ts

@@ -0,0 +1,48 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBlockName, parseBlocksUntil } from "../utils";
+
+export interface IftagsBodyResult {
+  elements: Element[];
+  consumed: number;
+}
+
+export function parseIftagsBody(ctx: ParseContext, startPos: number): IftagsBodyResult {
+  const bodyCtx: ParseContext = { ...ctx, pos: startPos };
+  const bodyResult = parseBlocksUntil(bodyCtx, (checkCtx) => isIftagsClose(checkCtx, checkCtx.pos));
+
+  return {
+    elements: bodyResult.elements,
+    consumed: bodyResult.consumed,
+  };
+}
+
+export function isIftagsClose(ctx: ParseContext, pos: number): boolean {
+  const token = ctx.tokens[pos];
+  if (token?.type !== "BLOCK_END_OPEN") {
+    return false;
+  }
+
+  const closeNameResult = parseBlockName(ctx, pos + 1);
+  return closeNameResult?.name.toLowerCase() === "iftags";
+}
+
+export function consumeIftagsClose(ctx: ParseContext, startPos: number): number {
+  let pos = startPos + 1;
+  let consumed = 1;
+
+  const closeNameResult = parseBlockName(ctx, pos);
+  if (closeNameResult) {
+    pos += closeNameResult.consumed;
+    consumed += closeNameResult.consumed;
+  }
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    pos++;
+    consumed++;
+  }
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return consumed;
+}

package/src/parser/rules/block/iftags/condition.ts

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

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

@@ -0,0 +1,108 @@
+/**
+ *
+ * Block rule for Wikidot conditional tag blocks: `[[iftags]]...[[/iftags]]`.
+ *
+ * The `[[iftags]]` construct conditionally includes or excludes its body
+ * content based on the page's tags. The condition expression is everything
+ * between the block name and `]]`, e.g.:
+ *
+ * ```
+ * [[iftags +scp -tale]]
+ * This content only shows if the page has tag "scp" and not "tale".
+ * [[/iftags]]
+ * ```
+ *
+ * The condition string is stored as-is in the AST; actual evaluation is
+ * performed at render time based on the page's tag set.
+ *
+ * Body content is parsed as normal block-level markup using
+ * {@link parseBlocksUntil}.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseBlockName } from "../utils";
+import { collectIftagsCondition } from "./condition";
+import { consumeIftagsClose, isIftagsClose, parseIftagsBody } from "./body";
+
+/**
+ * Block rule for `[[iftags condition]]...[[/iftags]]`.
+ *
+ * Produces an `if-tags` element containing the condition string and
+ * the parsed body elements.
+ */
+export const iftagsRule: BlockRule = {
+  name: "iftags",
+  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.toLowerCase() !== "iftags") {
+      return { success: false };
+    }
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
+
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+
+    const conditionResult = collectIftagsCondition(ctx, pos);
+    pos += conditionResult.consumed;
+    consumed += conditionResult.consumed;
+
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+
+    if (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+
+    const bodyResult = parseIftagsBody(ctx, pos);
+    pos += bodyResult.consumed;
+    consumed += bodyResult.consumed;
+
+    if (!isIftagsClose(ctx, pos)) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/iftags]] for [[iftags]]",
+        position: openToken.position,
+      });
+    } else {
+      const closeConsumed = consumeIftagsClose(ctx, pos);
+      pos += closeConsumed;
+      consumed += closeConsumed;
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "if-tags",
+          data: {
+            condition: conditionResult.condition.trim(),
+            elements: bodyResult.elements,
+          },
+        },
+      ],
+      consumed,
+    };
+  },
+};

package/src/parser/rules/block/include/arguments.ts

@@ -0,0 +1,48 @@
+import type { ParseContext } from "../../types";
+
+export interface IncludeArguments {
+  target: string;
+  argumentTokens: string[];
+  consumed: number;
+}
+
+export function collectIncludeArguments(ctx: ParseContext, startPos: number): IncludeArguments {
+  const argumentTokens: string[] = [];
+  let target = "";
+  let inTarget = true;
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "BLOCK_CLOSE") {
+      break;
+    }
+
+    if (token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    if (inTarget) {
+      if (token.type === "WHITESPACE") {
+        if (target) {
+          inTarget = false;
+        }
+      } else if (token.type === "PIPE") {
+        inTarget = false;
+        argumentTokens.push("|");
+      } else {
+        target += token.value;
+      }
+    } else {
+      argumentTokens.push(token.value);
+    }
+
+    pos++;
+    consumed++;
+  }
+
+  return { target, argumentTokens, consumed };
+}

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

@@ -0,0 +1,75 @@
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseBlockName } from "../utils";
+import { collectIncludeArguments } from "./arguments";
+import { parsePageRef } from "./location";
+import { parseVariables } from "./variables";
+
+export const includeRule: BlockRule = {
+  name: "include",
+  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.toLowerCase() !== "include") {
+      return { success: false };
+    }
+
+    if (!ctx.settings.enablePageSyntax) {
+      return { success: false };
+    }
+
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
+
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+
+    const args = collectIncludeArguments(ctx, pos);
+    pos += args.consumed;
+    consumed += args.consumed;
+
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+
+    if (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+
+    if (!args.target) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "include",
+          data: {
+            "paragraph-safe": false,
+            variables: parseVariables(args.argumentTokens),
+            location: parsePageRef(args.target),
+            elements: [],
+          },
+        },
+      ],
+      consumed,
+    };
+  },
+};

package/src/parser/rules/block/include/location.ts

@@ -0,0 +1,24 @@
+import type { PageRef } from "@wdprlib/ast";
+
+/**
+ * Parse page reference from include target.
+ *
+ * Formats:
+ * - `page` -> `{ site: null, page: "page" }`
+ * - `:site:page` -> `{ site: "site", page: "page" }`
+ * - `fragment:name` -> `{ site: null, page: "fragment:name" }`
+ */
+export function parsePageRef(target: string): PageRef {
+  if (target.startsWith(":")) {
+    const rest = target.slice(1);
+    const colonIndex = rest.indexOf(":");
+    if (colonIndex !== -1) {
+      return {
+        site: rest.slice(0, colonIndex),
+        page: rest.slice(colonIndex + 1),
+      };
+    }
+  }
+
+  return { site: null, page: target };
+}

package/src/parser/rules/block/include/variables.ts

@@ -0,0 +1,37 @@
+import type { VariableMap } from "@wdprlib/ast";
+
+export function parseVariables(tokens: string[]): VariableMap {
+  const vars: VariableMap = {};
+  let current = "";
+
+  for (const token of tokens) {
+    if (token === "|") {
+      assignVariable(vars, current);
+      current = "";
+    } else {
+      current += token;
+    }
+  }
+
+  assignVariable(vars, current);
+
+  return vars;
+}
+
+function assignVariable(vars: VariableMap, source: string): void {
+  if (!source.trim()) {
+    return;
+  }
+
+  const eqIndex = source.indexOf("=");
+  if (eqIndex === -1) {
+    return;
+  }
+
+  const key = source.slice(0, eqIndex).trim();
+  if (!key) {
+    return;
+  }
+
+  vars[key] = source.slice(eqIndex + 1).trim();
+}