@wdprlib/ast 2.0.0 → 2.1.0

package/dist/index.js

@@ -193,6 +193,394 @@ function isParagraphSafe(element) {
 }
 // packages/ast/src/constants.ts
 var STYLE_SLOT_PREFIX = "\x00__IFTAGS_SLOT__";
+// packages/ast/src/expr-eval.ts
+var FALSE_VALUES = new Set(["false", "null", "", "0"]);
+function isTruthy(value) {
+  return !FALSE_VALUES.has(value.toLowerCase().trim());
+}
+var MAX_EXPRESSION_LENGTH = 256;
+function isTruthyNum(n) {
+  return n !== 0 && !Number.isNaN(n);
+}
+function formatExprValue(n) {
+  return String(n);
+}
+function evaluateExpression(expr) {
+  try {
+    if (expr.length > MAX_EXPRESSION_LENGTH) {
+      return { success: false, error: "expression too long" };
+    }
+    if (expr.trim() === "") {
+      return { success: false, error: "empty expression" };
+    }
+    const tokens = tokenize(expr);
+    if (tokens.length <= 1) {
+      return { success: false, error: "empty expression" };
+    }
+    const parser = new ExprParser(tokens);
+    const result = parser.parse();
+    if (!Number.isFinite(result)) {
+      return { success: false, error: "division by zero" };
+    }
+    return { success: true, value: result };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : "unknown error";
+    return { success: false, error: msg };
+  }
+}
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (/\d/.test(ch) || ch === "." && /\d/.test(expr[i + 1] ?? "")) {
+      let numStr = "";
+      let hasDot = false;
+      while (i < expr.length) {
+        const c = expr[i];
+        if (c === ".") {
+          if (hasDot)
+            break;
+          hasDot = true;
+        } else if (!/\d/.test(c)) {
+          break;
+        }
+        numStr += c;
+        i++;
+      }
+      const num = parseFloat(numStr);
+      if (!Number.isFinite(num)) {
+        throw new Error("Invalid number");
+      }
+      tokens.push({ kind: "NUMBER", value: num });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(ch)) {
+      let id = "";
+      while (i < expr.length) {
+        const c = expr[i];
+        if (!/[a-zA-Z0-9_]/.test(c))
+          break;
+        id += c;
+        i++;
+      }
+      tokens.push({ kind: "IDENTIFIER", value: id.toLowerCase() });
+      continue;
+    }
+    if (ch === "<" && expr[i + 1] === "=") {
+      tokens.push({ kind: "LE", value: "<=" });
+      i += 2;
+      continue;
+    }
+    if (ch === ">" && expr[i + 1] === "=") {
+      tokens.push({ kind: "GE", value: ">=" });
+      i += 2;
+      continue;
+    }
+    if (ch === "!" && expr[i + 1] === "=") {
+      tokens.push({ kind: "NE", value: "!=" });
+      i += 2;
+      continue;
+    }
+    if (ch === "<" && expr[i + 1] === ">") {
+      tokens.push({ kind: "NE", value: "<>" });
+      i += 2;
+      continue;
+    }
+    if (ch === "!") {
+      tokens.push({ kind: "BANG", value: "!" });
+      i++;
+      continue;
+    }
+    switch (ch) {
+      case "+":
+        tokens.push({ kind: "PLUS", value: "+" });
+        break;
+      case "-":
+        tokens.push({ kind: "MINUS", value: "-" });
+        break;
+      case "*":
+        tokens.push({ kind: "STAR", value: "*" });
+        break;
+      case "/":
+        tokens.push({ kind: "SLASH", value: "/" });
+        break;
+      case "%":
+        tokens.push({ kind: "PERCENT", value: "%" });
+        break;
+      case "^":
+        tokens.push({ kind: "CARET", value: "^" });
+        break;
+      case "(":
+        tokens.push({ kind: "LPAREN", value: "(" });
+        break;
+      case ")":
+        tokens.push({ kind: "RPAREN", value: ")" });
+        break;
+      case ",":
+        tokens.push({ kind: "COMMA", value: "," });
+        break;
+      case "<":
+        tokens.push({ kind: "LT", value: "<" });
+        break;
+      case ">":
+        tokens.push({ kind: "GT", value: ">" });
+        break;
+      case "=":
+        tokens.push({ kind: "EQ", value: "=" });
+        break;
+      default:
+        throw new Error(`Unknown character: ${ch}`);
+    }
+    i++;
+  }
+  tokens.push({ kind: "EOF", value: "" });
+  return tokens;
+}
+
+class ExprParser {
+  tokens;
+  pos = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  parse() {
+    const result = this.parseOr();
+    if (this.current().kind !== "EOF") {
+      throw new Error("too many values in the stack");
+    }
+    return result;
+  }
+  current() {
+    return this.tokens[this.pos] ?? { kind: "EOF", value: "" };
+  }
+  advance() {
+    const token = this.current();
+    this.pos++;
+    return token;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.current().kind === "IDENTIFIER" && this.current().value === "or") {
+      this.advance();
+      const right = this.parseAnd();
+      left = isTruthyNum(left) || isTruthyNum(right) ? 1 : 0;
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.current().kind === "IDENTIFIER" && this.current().value === "and") {
+      this.advance();
+      const right = this.parseNot();
+      left = isTruthyNum(left) && isTruthyNum(right) ? 1 : 0;
+    }
+    return left;
+  }
+  parseNot() {
+    const cur = this.current();
+    if (cur.kind === "IDENTIFIER" && cur.value === "not" || cur.kind === "BANG") {
+      this.advance();
+      const value = this.parseNot();
+      return isTruthyNum(value) ? 0 : 1;
+    }
+    return this.parseComparison();
+  }
+  parseComparison() {
+    let left = this.parseAddition();
+    const kind = this.current().kind;
+    if (kind === "LT" || kind === "GT" || kind === "LE" || kind === "GE" || kind === "EQ" || kind === "NE") {
+      this.advance();
+      const right = this.parseAddition();
+      switch (kind) {
+        case "LT":
+          return left < right ? 1 : 0;
+        case "GT":
+          return left > right ? 1 : 0;
+        case "LE":
+          return left <= right ? 1 : 0;
+        case "GE":
+          return left >= right ? 1 : 0;
+        case "EQ":
+          return left === right ? 1 : 0;
+        case "NE":
+          return left !== right ? 1 : 0;
+      }
+    }
+    return left;
+  }
+  parseAddition() {
+    let left = this.parseMultiplication();
+    while (true) {
+      const kind = this.current().kind;
+      if (kind === "PLUS") {
+        this.advance();
+        left = left + this.parseMultiplication();
+      } else if (kind === "MINUS") {
+        this.advance();
+        left = left - this.parseMultiplication();
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  parseMultiplication() {
+    let left = this.parsePower();
+    while (true) {
+      const kind = this.current().kind;
+      if (kind === "STAR") {
+        this.advance();
+        left = left * this.parsePower();
+      } else if (kind === "SLASH") {
+        this.advance();
+        left = left / this.parsePower();
+      } else if (kind === "PERCENT") {
+        this.advance();
+        left = left % this.parsePower();
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  parsePower() {
+    const left = this.parseUnary();
+    if (this.current().kind === "CARET") {
+      this.advance();
+      const right = this.parsePower();
+      return Math.pow(left, right);
+    }
+    return left;
+  }
+  parseUnary() {
+    const kind = this.current().kind;
+    if (kind === "MINUS") {
+      this.advance();
+      return -this.parseUnary();
+    }
+    if (kind === "PLUS") {
+      this.advance();
+      return +this.parseUnary();
+    }
+    if (kind === "BANG") {
+      this.advance();
+      const value = this.parseUnary();
+      return isTruthyNum(value) ? 0 : 1;
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const token = this.current();
+    if (token.kind === "NUMBER") {
+      this.advance();
+      return token.value;
+    }
+    if (token.kind === "LPAREN") {
+      this.advance();
+      const value = this.parseOr();
+      if (this.current().kind !== "RPAREN") {
+        throw new Error("Expected )");
+      }
+      this.advance();
+      return value;
+    }
+    if (token.kind === "IDENTIFIER") {
+      const name = token.value;
+      this.advance();
+      if (this.current().kind === "LPAREN") {
+        return this.parseFunctionCall(name);
+      }
+      if (name === "true")
+        return 1;
+      if (name === "false")
+        return 0;
+      throw new Error(`undefined constant "${name}"`);
+    }
+    throw new Error("Expected expression");
+  }
+  parseFunctionCall(name) {
+    if (this.current().kind !== "LPAREN") {
+      throw new Error("Expected (");
+    }
+    this.advance();
+    const args = [];
+    if (this.current().kind !== "RPAREN") {
+      args.push(this.parseOr());
+      while (this.current().kind === "COMMA") {
+        this.advance();
+        args.push(this.parseOr());
+      }
+    }
+    if (this.current().kind !== "RPAREN") {
+      throw new Error("Expected )");
+    }
+    this.advance();
+    return this.callFunction(name, args);
+  }
+  callFunction(name, args) {
+    switch (name) {
+      case "abs":
+        this.checkArgs(name, args, 1);
+        return Math.abs(args[0]);
+      case "min":
+        this.checkArgsMin(name, args, 1);
+        return Math.min(...args);
+      case "max":
+        this.checkArgsMin(name, args, 1);
+        return Math.max(...args);
+      case "floor":
+        this.checkArgs(name, args, 1);
+        return Math.floor(args[0]);
+      case "ceil":
+        this.checkArgs(name, args, 1);
+        return Math.ceil(args[0]);
+      case "round":
+        this.checkArgs(name, args, 1);
+        return Math.round(args[0]);
+      case "sqrt":
+        this.checkArgs(name, args, 1);
+        return Math.sqrt(args[0]);
+      case "sin":
+        this.checkArgs(name, args, 1);
+        return Math.sin(args[0]);
+      case "cos":
+        this.checkArgs(name, args, 1);
+        return Math.cos(args[0]);
+      case "tan":
+        this.checkArgs(name, args, 1);
+        return Math.tan(args[0]);
+      case "ln":
+        this.checkArgs(name, args, 1);
+        return Math.log(args[0]);
+      case "log":
+        this.checkArgs(name, args, 1);
+        return Math.log10(args[0]);
+      case "exp":
+        this.checkArgs(name, args, 1);
+        return Math.exp(args[0]);
+      case "pow":
+        this.checkArgs(name, args, 2);
+        return Math.pow(args[0], args[1]);
+      default:
+        throw new Error(`undefined function "${name}"`);
+    }
+  }
+  checkArgs(name, args, expected) {
+    if (args.length !== expected) {
+      throw new Error(`${name}() expects ${expected} argument(s), got ${args.length}`);
+    }
+  }
+  checkArgsMin(name, args, min) {
+    if (args.length < min) {
+      throw new Error(`${name}() expects at least ${min} argument(s), got ${args.length}`);
+    }
+  }
+}
 // packages/ast/src/settings.ts
 function createSettings(mode) {
   switch (mode) {
@@ -236,6 +624,7 @@ export {
   link,
   lineBreak,
   italics,
+  isTruthy,
   isStringContainerType,
   isParagraphSafe,
   isHeaderType,
@@ -243,6 +632,8 @@ export {
   isAlignType,
   horizontalRule,
   heading,
+  formatExprValue,
+  evaluateExpression,
   createSettings,
   createPosition,
   createPoint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdprlib/ast",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "AST types for Wikidot markup",
   "keywords": [
     "ast",
@@ -15,7 +15,8 @@
     "directory": "packages/ast"
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "type": "module",
   "sideEffects": false,
@@ -24,6 +25,7 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"

package/src/constants.ts

@@ -0,0 +1,12 @@
+/**
+ * Sentinel prefix for style slot placeholders in {@link SyntaxTree.styles}.
+ *
+ * When the resolver encounters an unresolved `[[iftags]]` block containing
+ * `[[module CSS]]`, it inserts a sentinel string (`STYLE_SLOT_PREFIX + slotId`)
+ * into the styles array to preserve source order. At render time the sentinel
+ * is replaced with the actual CSS collected from the iftags block (if the
+ * condition matches).
+ *
+ * A null-byte prefix ensures no collision with valid CSS content.
+ */
+export const STYLE_SLOT_PREFIX = "\0__IFTAGS_SLOT__";

package/src/diagnostic.ts

@@ -0,0 +1,104 @@
+/**
+ * Diagnostic types for reporting parse-time issues.
+ *
+ * When the parser encounters syntactically questionable or invalid markup
+ * (e.g. an unclosed `[[div]]` block), it records a {@link Diagnostic} rather
+ * than throwing an error. The parser is lenient: it always produces an AST,
+ * even when diagnostics are present.
+ *
+ * Diagnostics are returned alongside the AST via {@link ParseResult}.
+ *
+ * @since 2.0.0
+ * @module
+ */
+
+import type { Position } from "./position";
+import type { SyntaxTree } from "./element";
+
+/**
+ * Severity level of a diagnostic.
+ *
+ * - `"error"` — the markup is structurally broken (e.g. inline `[[div]]`
+ *   without a newline after `]]`).
+ * - `"warning"` — the markup is likely unintentional but the parser can
+ *   recover (e.g. a missing `[[/div]]` close tag).
+ * - `"info"` — informational hints (e.g. deprecated syntax).
+ *
+ * @since 2.0.0
+ * @group Diagnostics
+ */
+export type DiagnosticSeverity = "error" | "warning" | "info";
+
+/**
+ * A single diagnostic emitted during parsing.
+ *
+ * Each diagnostic pinpoints a source location via {@link Position} and
+ * carries a machine-readable {@link Diagnostic.code | code} string for
+ * programmatic filtering (e.g. `"unclosed-block"`, `"inline-block-element"`).
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@wdprlib/parser";
+ *
+ * const { ast, diagnostics } = parse("[[div]]\nHello");
+ * for (const d of diagnostics) {
+ *   console.log(`[${d.severity}] ${d.message} (line ${d.position.start.line})`);
+ * }
+ * ```
+ *
+ * @since 2.0.0
+ * @group Diagnostics
+ */
+export interface Diagnostic {
+  /** How severe the issue is. */
+  severity: DiagnosticSeverity;
+
+  /**
+   * Machine-readable identifier for the diagnostic kind.
+   *
+   * Current codes:
+   * - `"unclosed-block"` — a block element has no matching close tag.
+   * - `"inline-block-element"` — a block element (e.g. `[[div]]`) is used
+   *   inline without the required trailing newline.
+   */
+  code: string;
+
+  /** Human-readable description of the issue. */
+  message: string;
+
+  /** Source range where the issue was detected. */
+  position: Position;
+
+  /**
+   * An optional related source range that provides additional context
+   * (e.g. the opening tag position when reporting a missing close tag).
+   */
+  relatedPosition?: Position;
+}
+
+/**
+ * The result of parsing a Wikidot markup string.
+ *
+ * Contains both the parsed AST and any diagnostics emitted during parsing.
+ * The AST is always produced, even when diagnostics are present — the parser
+ * is lenient and recovers from errors.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@wdprlib/parser";
+ *
+ * const result = parse("**bold** and //italic//");
+ * console.log(result.ast.elements); // AST nodes
+ * console.log(result.diagnostics);  // [] (no issues)
+ * ```
+ *
+ * @since 2.0.0
+ * @group Diagnostics
+ */
+export interface ParseResult {
+  /** The parsed syntax tree. */
+  ast: SyntaxTree;
+
+  /** Diagnostics emitted during parsing (empty when the input is clean). */
+  diagnostics: Diagnostic[];
+}