@wdprlib/ast 2.0.0 → 2.2.0

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(exports_src, {
   link: () => link,
   lineBreak: () => lineBreak,
   italics: () => italics,
+  isTruthy: () => isTruthy,
   isStringContainerType: () => isStringContainerType,
   isParagraphSafe: () => isParagraphSafe,
   isHeaderType: () => isHeaderType,
@@ -45,13 +46,16 @@ __export(exports_src, {
   isAlignType: () => isAlignType,
   horizontalRule: () => horizontalRule,
   heading: () => heading,
+  formatExprValue: () => formatExprValue,
+  evaluateExpression: () => evaluateExpression,
   createSettings: () => createSettings,
   createPosition: () => createPosition,
   createPoint: () => createPoint,
   container: () => container,
   bold: () => bold,
   STYLE_SLOT_PREFIX: () => STYLE_SLOT_PREFIX,
-  DEFAULT_SETTINGS: () => DEFAULT_SETTINGS
+  DEFAULT_SETTINGS: () => DEFAULT_SETTINGS,
+  CSS_LENGTH_UNITS: () => CSS_LENGTH_UNITS
 });
 module.exports = __toCommonJS(exports_src);
 
@@ -250,6 +254,447 @@ function isParagraphSafe(element) {
 }
 // packages/ast/src/constants.ts
 var STYLE_SLOT_PREFIX = "\x00__IFTAGS_SLOT__";
+// packages/ast/src/css.ts
+var CSS_LENGTH_UNITS = [
+  "cqmax",
+  "cqmin",
+  "cqw",
+  "cqh",
+  "cqi",
+  "cqb",
+  "svmin",
+  "svmax",
+  "lvmin",
+  "lvmax",
+  "dvmin",
+  "dvmax",
+  "vmin",
+  "vmax",
+  "svw",
+  "svh",
+  "svi",
+  "svb",
+  "lvw",
+  "lvh",
+  "lvi",
+  "lvb",
+  "dvw",
+  "dvh",
+  "dvi",
+  "dvb",
+  "vw",
+  "vh",
+  "vi",
+  "vb",
+  "rcap",
+  "rem",
+  "rex",
+  "rch",
+  "ric",
+  "rlh",
+  "cap",
+  "em",
+  "ex",
+  "ch",
+  "ic",
+  "lh",
+  "cm",
+  "mm",
+  "in",
+  "pc",
+  "pt",
+  "px",
+  "q",
+  "%"
+];
+// 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) {

package/dist/index.d.cts

@@ -64,22 +64,29 @@ declare function createPoint(line: number, column: number, offset: number): Poin
 */
 declare function createPosition(start: Point, end: Point): Position;
 /**
-* AST element types for Wikidot markup.
+* Shared CSS value definitions used across parser and renderer.
 *
-* Wikidot markup (`+ heading`, `**bold**`, `[[module ListPages]]`, etc.) is parsed into
-* a structured representation defined here. Each {@link Element} is a tagged union of
-* `{ element: tag, data: payload }`, where the data shape for each tag is defined in
-* {@link ElementDataMap}.
+* @module
+*/
+/**
+* All CSS length units (plus percentage) accepted where Wikidot markup
+* takes a size value.
 *
-* @example
-* ```ts
-* import { parse } from "@wdprlib/parser";
-* const tree = parse("**Hello** world");
-* // tree.elements[0] → { element: "container", data: { type: "paragraph", ... } }
-* ```
+* This is intentionally a superset of what legacy Wikidot accepts: wdpr
+* extends size validation to modern CSS units (viewport, container-query,
+* and root-relative units) instead of mirroring Wikidot's historical
+* `px|em|%` allowlists. Units are canonicalized to lowercase.
 *
-* @module
+* @group CSS
+*/
+declare const CSS_LENGTH_UNITS: readonly ["cqmax", "cqmin", "cqw", "cqh", "cqi", "cqb", "svmin", "svmax", "lvmin", "lvmax", "dvmin", "dvmax", "vmin", "vmax", "svw", "svh", "svi", "svb", "lvw", "lvh", "lvi", "lvb", "dvw", "dvh", "dvi", "dvb", "vw", "vh", "vi", "vb", "rcap", "rem", "rex", "rch", "ric", "rlh", "cap", "em", "ex", "ch", "ic", "lh", "cm", "mm", "in", "pc", "pt", "px", "q", "%"];
+/**
+* A CSS length unit (or percentage) accepted in size values,
+* canonicalized to lowercase.
+*
+* @group CSS
 */
+type CssLengthUnit = (typeof CSS_LENGTH_UNITS)[number];
 /**
 * Key-value map of HTML attributes.
 * Populated from the Wikidot `_ class="foo" style="color:red"` attribute syntax.
@@ -488,6 +495,25 @@ type Module = {
 } | {
 	/** `[[module Rate]]` — page rating widget */
 	module: "rate";
+} | {
+	/** `[[module TagCloud]]` — weighted cloud of page tags */
+	module: "tag-cloud";
+	/** Numeric part of the font size for the lightest-weighted tag */
+	"min-font-size": number;
+	/** Numeric part of the font size for the heaviest-weighted tag */
+	"max-font-size": number;
+	/** Unit shared by both font sizes (lowercase) */
+	"font-size-unit": CssLengthUnit;
+	/** RGB components for the lightest-weighted tag */
+	"min-color": [number, number, number];
+	/** RGB components for the heaviest-weighted tag */
+	"max-color": [number, number, number];
+	/** Normalized link target prefix, always ending with `/tag/` */
+	target: string;
+	/** Maximum number of tags to display */
+	limit: number;
+	/** Category filter, or null for all categories */
+	category: string | null;
 } | {
 	/** `[[module ListUsers]]` — user listing with template body */
 	module: "list-users";
@@ -1251,6 +1277,51 @@ declare function createSettings(mode: WikitextMode): WikitextSettings;
 */
 declare const DEFAULT_SETTINGS: WikitextSettings;
 /**
+* Determine whether a string value is truthy for Wikidot's `#if` construct.
+*
+* The value is lowercased and trimmed before checking against the set of
+* known falsy strings (`"false"`, `"null"`, `""`, `"0"`).
+*
+* @param value - The condition string to check.
+* @returns `true` if the value is not in the falsy set.
+*/
+declare function isTruthy(value: string): boolean;
+/**
+* Result of evaluating a mathematical expression.
+* Either a successful numeric value or an error message string.
+*/
+type ExprResult = {
+	success: true;
+	value: number;
+} | {
+	success: false;
+	error: string;
+};
+/**
+* Format a numeric expression result for display.
+*
+* Uses JavaScript's default `String(n)` so the full precision of the
+* computed value is preserved (e.g. `1/3` becomes `"0.3333333333333333"`,
+* matching the `Number` → `String` conversion rather than truncating to
+* a fixed number of decimals). Used by both the inline renderer and the
+* opener preprocess so the same expression produces the same string
+* regardless of where it appears in the source.
+*/
+declare function formatExprValue(n: number): string;
+/**
+* Evaluate a mathematical expression string and return the result.
+*
+* The expression is tokenized, parsed with a recursive descent parser,
+* and evaluated in a single pass. Errors produce Wikidot-compatible
+* messages (e.g., `"division by zero"`, `"too many values in the stack"`).
+*
+* NaN and Infinity results are treated as division-by-zero errors.
+*
+* @param expr - The expression string to evaluate.
+* @returns A success result with a numeric value, or an error result with a message.
+*/
+declare function evaluateExpression(expr: string): ExprResult;
+/**
 * Identifies the source markup dialect.
 *
 * Currently only `"wikidot"` is supported. Included in {@link SyntaxTree}
@@ -1259,4 +1330,4 @@ declare const DEFAULT_SETTINGS: WikitextSettings;
 * @group Core
 */
 type Version = "wikidot";
-export { text, paragraph, listItemSubList, listItemElements, list, link, lineBreak, italics, isStringContainerType, isParagraphSafe, isHeaderType, isContainerTypeParagraphSafe, isAlignType, horizontalRule, heading, createSettings, createPosition, createPoint, container, bold, WikitextSettings, WikitextMode, Version, VariableMap, UserData, TocEntry, TableRow, TableOfContentsData, TableData, TableCell, TabData, SyntaxTree, StringContainerType, STYLE_SLOT_PREFIX, Position, Point, ParseResult, PageRef, Module, MathInlineData, MathData, ListType, ListItem, ListData, LinkType, LinkLocation, LinkLabel, LinkData, IncludeData, ImageSource, ImageData, IframeData, IfTagsData, IfExprData, IfCondData, HtmlData, HeadingLevel, Heading, HeaderType, FootnoteBlockData, FloatAlignment, ExprData, EmbedBlockData, Embed, ElementOf, ElementName, ElementDataMap, ElementData, Element, DiagnosticSeverity, Diagnostic, DefinitionListItem, DateItem, DateData, DEFAULT_SETTINGS, ContainerType, ContainerData, ColorData, CollapsibleData, CodeBlockData, ClearFloat, BibliographyCiteData, BibliographyBlockData, AttributeMap, AnchorTarget, AnchorData, Alignment, AlignType };
+export { text, paragraph, listItemSubList, listItemElements, list, link, lineBreak, italics, isTruthy, isStringContainerType, isParagraphSafe, isHeaderType, isContainerTypeParagraphSafe, isAlignType, horizontalRule, heading, formatExprValue, evaluateExpression, createSettings, createPosition, createPoint, container, bold, WikitextSettings, WikitextMode, Version, VariableMap, UserData, TocEntry, TableRow, TableOfContentsData, TableData, TableCell, TabData, SyntaxTree, StringContainerType, STYLE_SLOT_PREFIX, Position, Point, ParseResult, PageRef, Module, MathInlineData, MathData, ListType, ListItem, ListData, LinkType, LinkLocation, LinkLabel, LinkData, IncludeData, ImageSource, ImageData, IframeData, IfTagsData, IfExprData, IfCondData, HtmlData, HeadingLevel, Heading, HeaderType, FootnoteBlockData, FloatAlignment, ExprResult, ExprData, EmbedBlockData, Embed, ElementOf, ElementName, ElementDataMap, ElementData, Element, DiagnosticSeverity, Diagnostic, DefinitionListItem, DateItem, DateData, DEFAULT_SETTINGS, CssLengthUnit, ContainerType, ContainerData, ColorData, CollapsibleData, CodeBlockData, ClearFloat, CSS_LENGTH_UNITS, BibliographyCiteData, BibliographyBlockData, AttributeMap, AnchorTarget, AnchorData, Alignment, AlignType };