@wdprlib/parser 3.1.1 → 3.2.0

package/dist/index.js

@@ -9077,6 +9077,8 @@ function parseTagCondition(condition) {
   const required = [];
   const forbidden = [];
   const optional = [];
+  let hasEmptyRequired = false;
+  let hasEmptyForbidden = false;
   const parts = condition.trim().split(/\s+/);
   for (const part of parts) {
     if (!part)
@@ -9085,20 +9087,31 @@ function parseTagCondition(condition) {
       const tag = part.slice(1);
       if (tag)
         required.push(tag);
+      else
+        hasEmptyRequired = true;
     } else if (part.startsWith("-")) {
       const tag = part.slice(1);
       if (tag)
         forbidden.push(tag);
+      else
+        hasEmptyForbidden = true;
     } else {
       optional.push(part);
     }
   }
-  return { required, forbidden, optional };
+  return { required, forbidden, optional, hasEmptyRequired, hasEmptyForbidden };
 }
 function evaluateTagCondition(condition, pageTags) {
-  if (condition.required.length === 0 && condition.forbidden.length === 0 && condition.optional.length === 0) {
+  const noNamedTokens = condition.required.length === 0 && condition.forbidden.length === 0 && condition.optional.length === 0;
+  if (noNamedTokens && !condition.hasEmptyRequired && !condition.hasEmptyForbidden) {
     return false;
   }
+  if (condition.hasEmptyRequired) {
+    return false;
+  }
+  if (condition.hasEmptyForbidden && noNamedTokens) {
+    return true;
+  }
   const tagSet = new Set(pageTags);
   for (const tag of condition.required) {
     if (!tagSet.has(tag)) {
@@ -9118,19 +9131,10 @@ function evaluateTagCondition(condition, pageTags) {
   return true;
 }
 
-// packages/parser/src/parser/rules/block/module/iftags/preprocess.ts
-var BASE_PLACEHOLDER_OPEN = "";
-var BASE_PLACEHOLDER_CLOSE = "";
-var INNERMOST_IFTAGS_PATTERN = /\[\[\s*iftags\b([^\]]*)\]\]((?:(?!\[\[\s*iftags\b|\[\[\/\s*iftags\s*\]\]).)*)\[\[\/\s*iftags\s*\]\]/gis;
+// packages/parser/src/parser/preprocess/utils.ts
+var BASE_PLACEHOLDER_OPEN = "";
+var BASE_PLACEHOLDER_CLOSE = "";
 var RAW_BLOCK_OPEN_PATTERN = /\[\[\s*(code|html)\b[^\]]*\]\]/iy;
-function preprocessIftags(source, pageTags) {
-  if (!source.includes("[["))
-    return source;
-  const sentinels = makeUniqueSentinels(source);
-  const { masked, placeholders } = maskRawRegions(source, sentinels);
-  const reduced = reduceIftags(masked, pageTags);
-  return restorePlaceholders(reduced, placeholders, sentinels);
-}
 function makeUniqueSentinels(source) {
   let open = BASE_PLACEHOLDER_OPEN;
   let close = BASE_PLACEHOLDER_CLOSE;
@@ -9140,46 +9144,91 @@ function makeUniqueSentinels(source) {
   }
   return { open, close };
 }
-function reduceIftags(source, pageTags) {
-  let current = source;
-  const maxIterations = source.length + 1;
-  const tagSet = pageTags ?? [];
-  for (let i = 0;i < maxIterations; i++) {
-    const depths = pageTags === null ? computeBracketDepths(current) : null;
-    let changed = false;
-    const next = current.replace(INNERMOST_IFTAGS_PATTERN, (match, cond, body, offset) => {
-      if (depths !== null && depths[offset] === 0) {
-        return match;
+function maskRawRegions(source, sentinels) {
+  const placeholders = [];
+  let masked = "";
+  let i = 0;
+  while (i < source.length) {
+    if (source[i] === "[" && source[i + 1] === "[") {
+      RAW_BLOCK_OPEN_PATTERN.lastIndex = i;
+      const openMatch = RAW_BLOCK_OPEN_PATTERN.exec(source);
+      if (openMatch) {
+        const name = openMatch[1].toLowerCase();
+        const openLen = openMatch[0].length;
+        const closePattern = new RegExp(`\\[\\[\\/\\s*${name}\\s*\\]\\]`, "ig");
+        closePattern.lastIndex = i + openLen;
+        const closeMatch = closePattern.exec(source);
+        if (closeMatch) {
+          const regionEnd = closeMatch.index + closeMatch[0].length;
+          masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
+          i = regionEnd;
+          continue;
+        }
+        if (name === "code") {
+          masked += pushPlaceholder(placeholders, source.slice(i), sentinels);
+          i = source.length;
+          continue;
+        }
       }
-      changed = true;
-      const condition = parseTagCondition(cond);
-      return evaluateTagCondition(condition, tagSet) ? body : "";
-    });
-    if (!changed)
-      return current;
-    current = next;
+    }
+    if (source[i] === "@" && source[i + 1] === "<") {
+      const close = source.indexOf(">@", i + 2);
+      const newline = source.indexOf(`
+`, i + 2);
+      if (close !== -1 && (newline === -1 || close < newline)) {
+        const regionEnd = close + 2;
+        masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
+        i = regionEnd;
+        continue;
+      }
+    }
+    if (source[i] === "@" && source[i + 1] === "@") {
+      const close = source.indexOf("@@", i + 2);
+      const newline = source.indexOf(`
+`, i + 2);
+      if (close !== -1 && (newline === -1 || close < newline)) {
+        const regionEnd = close + 2;
+        masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
+        i = regionEnd;
+        continue;
+      }
+    }
+    masked += source[i];
+    i++;
   }
-  return current;
+  return { masked, placeholders };
+}
+function pushPlaceholder(placeholders, text, sentinels) {
+  const idx = placeholders.length;
+  placeholders.push(text);
+  return `${sentinels.open}${idx}${sentinels.close}`;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function restorePlaceholders(source, placeholders, sentinels) {
+  const pattern = new RegExp(`${escapeRegex(sentinels.open)}(\\d+)${escapeRegex(sentinels.close)}`, "g");
+  return source.replace(pattern, (_, idx) => placeholders[Number(idx)] ?? "");
 }
-function computeBracketDepths(masked) {
-  const n = masked.length;
+function computeBracketDepths(source) {
+  const n = source.length;
   const depths = new Int32Array(n + 1);
   let depth = 0;
   let i = 0;
   while (i < n) {
     depths[i] = depth;
-    const c = masked.charCodeAt(i);
-    const c1 = i + 1 < n ? masked.charCodeAt(i + 1) : -1;
-    const c2 = i + 2 < n ? masked.charCodeAt(i + 2) : -1;
-    if (depth > 0 && c === 34 && precededByEqualsAttr(masked, i)) {
-      const end = findQuoteEnd(masked, i + 1);
+    const c = source.charCodeAt(i);
+    const c1 = i + 1 < n ? source.charCodeAt(i + 1) : -1;
+    const c2 = i + 2 < n ? source.charCodeAt(i + 2) : -1;
+    if (depth > 0 && c === 34 && precededByEqualsAttr(source, i)) {
+      const end = findQuoteEnd(source, i + 1);
       for (let k = i;k <= end; k++)
         depths[k] = depth;
       i = end + 1;
       continue;
     }
     if (c === 91 && c1 === 91 && c2 === 91) {
-      const end = findTripleLinkEnd(masked, i + 3);
+      const end = findTripleLinkEnd(source, i + 3);
       for (let k = i;k <= end; k++)
         depths[k] = depth;
       i = end + 1;
@@ -9236,71 +9285,198 @@ function findTripleLinkEnd(s, from) {
   }
   return s.length - 1;
 }
-function maskRawRegions(source, sentinels) {
-  const placeholders = [];
-  let masked = "";
+
+// packages/parser/src/parser/rules/block/module/iftags/preprocess.ts
+var INNERMOST_IFTAGS_PATTERN = /\[\[\s*iftags\b([^\]]*)\]\]((?:(?!\[\[\s*iftags\b|\[\[\/\s*iftags\s*\]\]).)*)\[\[\/\s*iftags\s*\]\]/gis;
+function preprocessIftags(source, pageTags) {
+  if (!source.includes("[["))
+    return source;
+  const sentinels = makeUniqueSentinels(source);
+  const { masked, placeholders } = maskRawRegions(source, sentinels);
+  const reduced = reduceIftags(masked, pageTags);
+  return restorePlaceholders(reduced, placeholders, sentinels);
+}
+function reduceIftags(source, pageTags) {
+  let current = source;
+  const maxIterations = source.length + 1;
+  const tagSet = pageTags ?? [];
+  for (let i = 0;i < maxIterations; i++) {
+    const depths = pageTags === null ? computeBracketDepths(current) : null;
+    let changed = false;
+    const next = current.replace(INNERMOST_IFTAGS_PATTERN, (match, cond, body, offset) => {
+      if (depths !== null && depths[offset] === 0) {
+        return match;
+      }
+      changed = true;
+      const condition = parseTagCondition(cond);
+      return evaluateTagCondition(condition, tagSet) ? body : "";
+    });
+    if (!changed)
+      return current;
+    current = next;
+  }
+  return current;
+}
+
+// packages/parser/src/parser/preprocess/expr.ts
+import { evaluateExpression, formatExprValue, isTruthy } from "@wdprlib/ast";
+function preprocessExpr(source) {
+  if (!source.includes("[[#"))
+    return source;
+  const sentinels = makeUniqueSentinels(source);
+  const { masked, placeholders } = maskRawRegions(source, sentinels);
+  const reduced = reduceExpr(masked);
+  return restorePlaceholders(reduced, placeholders, sentinels);
+}
+function reduceExpr(source) {
+  let current = source;
+  const maxIterations = source.length + 1;
+  for (let i = 0;i < maxIterations; i++) {
+    const next = expandInnermost(current);
+    if (next === current)
+      return current;
+    current = next;
+  }
+  return current;
+}
+function expandInnermost(source) {
+  const depths = computeBracketDepths(source);
+  let result = "";
   let i = 0;
+  let replaced = false;
   while (i < source.length) {
-    if (source[i] === "[" && source[i + 1] === "[") {
-      RAW_BLOCK_OPEN_PATTERN.lastIndex = i;
-      const openMatch = RAW_BLOCK_OPEN_PATTERN.exec(source);
-      if (openMatch) {
-        const name = openMatch[1].toLowerCase();
-        const openLen = openMatch[0].length;
-        const closePattern = new RegExp(`\\[\\[\\/\\s*${name}\\s*\\]\\]`, "ig");
-        closePattern.lastIndex = i + openLen;
-        const closeMatch = closePattern.exec(source);
-        if (closeMatch) {
-          const regionEnd = closeMatch.index + closeMatch[0].length;
-          masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
-          i = regionEnd;
-          continue;
-        }
-        if (name === "code") {
-          masked += pushPlaceholder(placeholders, source.slice(i), sentinels);
-          i = source.length;
-          continue;
-        }
-      }
-    }
-    if (source[i] === "@" && source[i + 1] === "<") {
-      const close = source.indexOf(">@", i + 2);
-      const newline = source.indexOf(`
-`, i + 2);
-      if (close !== -1 && (newline === -1 || close < newline)) {
-        const regionEnd = close + 2;
-        masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
-        i = regionEnd;
+    const kind = matchDirectiveKind(source, i);
+    if (kind !== null && depths[i] > 0) {
+      const match = tryParseInnermostDirective(source, i, kind);
+      if (match !== null) {
+        result += evaluateDirective(kind, match);
+        i = match.end;
+        replaced = true;
         continue;
       }
     }
-    if (source[i] === "@" && source[i + 1] === "@") {
-      const close = source.indexOf("@@", i + 2);
-      const newline = source.indexOf(`
-`, i + 2);
-      if (close !== -1 && (newline === -1 || close < newline)) {
-        const regionEnd = close + 2;
-        masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
-        i = regionEnd;
-        continue;
+    result += source[i];
+    i++;
+  }
+  return replaced ? result : source;
+}
+function matchDirectiveKind(source, i) {
+  if (!source.startsWith("[[#", i))
+    return null;
+  if (source.startsWith("ifexpr", i + 3) && !isIdentChar(source[i + 9])) {
+    return "ifexpr";
+  }
+  if (source.startsWith("if", i + 3) && !isIdentChar(source[i + 5])) {
+    return "if";
+  }
+  if (source.startsWith("expr", i + 3) && !isIdentChar(source[i + 7])) {
+    return "expr";
+  }
+  return null;
+}
+function tryParseInnermostDirective(source, start, kind) {
+  const keywordLen = kind === "ifexpr" ? 6 : kind === "expr" ? 4 : 2;
+  let pos = start + 3 + keywordLen;
+  while (pos < source.length && isWhitespace(source[pos]))
+    pos++;
+  const headStart = pos;
+  let blockDepth = 0;
+  let linkDepth = 0;
+  const pipes = [];
+  let closeStart = -1;
+  while (pos < source.length) {
+    if (matchDirectiveKind(source, pos) !== null) {
+      return null;
+    }
+    if (source.startsWith("[[[", pos)) {
+      linkDepth++;
+      pos += 3;
+      continue;
+    }
+    if (linkDepth > 0 && source.startsWith("]]]", pos)) {
+      linkDepth--;
+      pos += 3;
+      continue;
+    }
+    if (linkDepth > 0) {
+      pos++;
+      continue;
+    }
+    if (source.startsWith("[[", pos)) {
+      blockDepth++;
+      pos += 2;
+      continue;
+    }
+    if (source.startsWith("]]", pos)) {
+      if (blockDepth === 0) {
+        closeStart = pos;
+        break;
       }
+      blockDepth--;
+      pos += 2;
+      continue;
     }
-    masked += source[i];
-    i++;
+    if (source[pos] === "|" && blockDepth === 0 && linkDepth === 0) {
+      pipes.push(pos);
+    }
+    pos++;
   }
-  return { masked, placeholders };
+  if (closeStart === -1)
+    return null;
+  const hasPipe = pipes.length > 0;
+  if (!hasPipe && (kind === "if" || kind === "ifexpr"))
+    return null;
+  let head;
+  let thenText = "";
+  let elseText = "";
+  if (!hasPipe) {
+    head = source.slice(headStart, closeStart).trim();
+  } else {
+    head = source.slice(headStart, pipes[0]).trim();
+    if (pipes.length >= 2) {
+      thenText = source.slice(pipes[0] + 1, pipes[1]).trim();
+      elseText = source.slice(pipes[1] + 1, closeStart).trim();
+    } else {
+      thenText = source.slice(pipes[0] + 1, closeStart).trim();
+    }
+  }
+  return {
+    end: closeStart + 2,
+    head,
+    thenText,
+    elseText,
+    hasPipe
+  };
 }
-function pushPlaceholder(placeholders, text, sentinels) {
-  const idx = placeholders.length;
-  placeholders.push(text);
-  return `${sentinels.open}${idx}${sentinels.close}`;
+function evaluateDirective(kind, m) {
+  if (kind === "expr") {
+    const result2 = evaluateExpression(m.head);
+    if (result2.success)
+      return formatExprValue(result2.value);
+    if (result2.error === "empty expression")
+      return "";
+    return "ERROR";
+  }
+  if (kind === "if") {
+    if (!m.hasPipe)
+      return "";
+    return isTruthy(m.head) ? m.thenText : m.elseText;
+  }
+  if (!m.hasPipe)
+    return "";
+  const result = evaluateExpression(m.head);
+  if (!result.success)
+    return "ERROR";
+  return result.value !== 0 && !Number.isNaN(result.value) ? m.thenText : m.elseText;
 }
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function isWhitespace(ch) {
+  return ch === " " || ch === "\t" || ch === `
+` || ch === "\r";
 }
-function restorePlaceholders(source, placeholders, sentinels) {
-  const pattern = new RegExp(`${escapeRegex(sentinels.open)}(\\d+)${escapeRegex(sentinels.close)}`, "g");
-  return source.replace(pattern, (_, idx) => placeholders[Number(idx)] ?? "");
+function isIdentChar(ch) {
+  if (!ch)
+    return false;
+  return /[a-z0-9_-]/i.test(ch);
 }
 
 // packages/parser/src/parser/parse.ts
@@ -9411,7 +9587,8 @@ class Parser {
   }
 }
 function parse(source, options) {
-  const iftagsProcessed = options?.pageTags !== undefined ? preprocessIftags(source, options.pageTags) : source;
+  const ifProcessed = preprocessExpr(source);
+  const iftagsProcessed = options?.pageTags !== undefined ? preprocessIftags(ifProcessed, options.pageTags) : ifProcessed;
   const preprocessed = preprocess(iftagsProcessed);
   const tokens = tokenize(preprocessed, { trackPositions: options?.trackPositions });
   return new Parser(tokens, options).parse();
@@ -10383,15 +10560,23 @@ async function resolveIncludesAsync(source, fetcher, options) {
   return expandIterativeAsync(source, cachedFetcher, maxIterations);
 }
 var INCLUDE_OPEN_PATTERN = /^\[\[include\s/gim;
+function hasAttributes(innerSoFar) {
+  if (innerSoFar.includes("|"))
+    return true;
+  const trimmed = innerSoFar.trimStart();
+  const ws = trimmed.search(/\s/);
+  if (ws === -1)
+    return false;
+  return trimmed.slice(ws).trim().length > 0;
+}
 function isRestOfLineBlank(source, pos) {
   for (let i = pos;i < source.length; i++) {
     const ch = source[i];
     if (ch === `
 `)
       return true;
-    if (ch === " " || ch === "\t" || ch === "\r" || ch === "]")
-      continue;
-    return false;
+    if (ch !== " " && ch !== "\t" && ch !== "\r")
+      return false;
   }
   return true;
 }
@@ -10425,6 +10610,12 @@ function scanIncludeDirectives(source) {
         depth--;
         i += 2;
         if (depth <= 0) {
+          const innerSoFar = source.slice(contentStart, closeStart);
+          if (hasAttributes(innerSoFar)) {
+            while (i < source.length && source[i] === "]") {
+              i++;
+            }
+          }
           const onOpenerLine = firstNewline === -1 || closeStart < firstNewline;
           if (onOpenerLine || isRestOfLineBlank(source, i)) {
             closeEnd = i;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdprlib/parser",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Parser for Wikidot markup",
   "keywords": [
     "ast",
@@ -15,7 +15,8 @@
     "directory": "packages/parser"
   },
   "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"
@@ -39,6 +41,6 @@
   },
   "dependencies": {
     "@braintree/sanitize-url": "^7.1.1",
-    "@wdprlib/ast": "2.0.0"
+    "@wdprlib/ast": "2.1.0"
   }
 }

package/src/index.ts

@@ -0,0 +1,163 @@
+/**
+ * Wikidot markup parser.
+ *
+ * This package converts Wikidot wikitext source into an abstract syntax
+ * tree (AST) defined by `@wdprlib/ast`. It also provides module-resolution
+ * utilities for dynamic constructs such as `[[module ListPages]]`,
+ * `[[module ListUsers]]`, `[[include]]`, and `[[iftags]]`.
+ *
+ * Typical usage:
+ *
+ * ```ts
+ * import { parse } from "@wdprlib/parser";
+ *
+ * const { ast, diagnostics } = parse("**bold** and //italic//");
+ * ```
+ *
+ * For server-side module resolution, see {@link extractDataRequirements},
+ * {@link resolveModules}, and {@link resolveIncludes}.
+ *
+ * @packageDocumentation
+ */
+
+// Re-export AST types and utilities from @wdprlib/ast
+export type {
+  Position,
+  Point,
+  Version,
+  Element,
+  SyntaxTree,
+  ContainerType,
+  ContainerData,
+  AttributeMap,
+  VariableMap,
+  Alignment,
+  LinkType,
+  LinkLocation,
+  LinkLabel,
+  PageRef,
+  ImageSource,
+  FloatAlignment,
+  ListType,
+  ListItem,
+  ListData,
+  CodeBlockData,
+  TabData,
+  TableCell,
+  TableRow,
+  TableData,
+  DefinitionListItem,
+  Module,
+  CollapsibleData,
+  ClearFloat,
+  AnchorTarget,
+  HeaderType,
+  AlignType,
+  HeadingLevel,
+  Heading,
+  DateItem,
+  Embed,
+  TocEntry,
+  // Diagnostics
+  Diagnostic,
+  DiagnosticSeverity,
+  ParseResult,
+} from "@wdprlib/ast";
+export {
+  createPoint,
+  createPosition,
+  text,
+  container,
+  paragraph,
+  bold,
+  italics,
+  heading,
+  lineBreak,
+  horizontalRule,
+  link,
+  list,
+  listItemElements,
+  listItemSubList,
+} from "@wdprlib/ast";
+
+// Wikitext settings (re-exported from @wdprlib/ast)
+export type { WikitextMode, WikitextSettings } from "@wdprlib/ast";
+export { createSettings, DEFAULT_SETTINGS } from "@wdprlib/ast";
+
+// Lexer
+export type { TokenType, Token, LexerOptions } from "./lexer";
+export { Lexer, tokenize, createToken } from "./lexer";
+
+// Parser
+export type { ParserOptions } from "./parser";
+export { Parser, parse } from "./parser";
+
+// Modules (ListPages, ListUsers, IfTags, Include, etc.)
+export type {
+  // ListPages query types
+  ListPagesQuery,
+  ListPagesVariable,
+  // Data requirement types
+  ListPagesDataRequirement,
+  DataRequirements,
+  // External data types
+  UserInfo,
+  PageData,
+  SiteContext,
+  ListPagesExternalData,
+  // Callback types
+  ListPagesDataFetcher,
+  DataProvider,
+  // Template types
+  VariableContext,
+  CompiledTemplate,
+  // Extraction types
+  ExtractionResult,
+  // Resolution types
+  ParseFunction,
+  ResolveOptions,
+  // Include resolution
+  IncludeFetcher,
+  AsyncIncludeFetcher,
+  ResolveIncludesOptions,
+  // ListUsers types
+  ListUsersVariable,
+  ListUsersUserData,
+  ListUsersDataRequirement,
+  ListUsersExternalData,
+  ListUsersDataFetcher,
+  ListUsersVariableContext,
+  ListUsersCompiledTemplate,
+  // Normalized query types
+  NormalizedListPagesQuery,
+  NormalizedTags,
+  NormalizedCategory,
+  NormalizedOrder,
+  NormalizedParent,
+  NormalizedDateSelector,
+  NormalizedNumericSelector,
+} from "./parser/rules/block/module/index";
+export {
+  extractDataRequirements,
+  resolveModules,
+  STYLE_SLOT_PREFIX,
+  compileTemplate,
+  // Include resolution
+  resolveIncludes,
+  resolveIncludesAsync,
+  // IfTags source-level preprocessing (run between include expansion and parse)
+  preprocessIftags,
+  // Query normalization (for advanced use cases)
+  normalizeQuery,
+  parseTags,
+  parseCategory,
+  parseOrder,
+  parseParent,
+  parseDateSelector,
+  parseNumericSelector,
+  // ListUsers
+  extractListUsersVariables,
+  compileListUsersTemplate,
+  isListUsersModule,
+  resolveListUsers,
+} from "./parser/rules/block/module/index";