@wdprlib/parser 4.4.0 → 5.1.0

package/dist/index.cjs

@@ -31,7 +31,7 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   tokenize: () => tokenize,
-  text: () => import_ast8.text,
+  text: () => import_ast9.text,
   resolveTagCloud: () => resolveTagCloud,
   resolveModules: () => resolveModules,
   resolveListUsers: () => resolveListUsers,
@@ -48,37 +48,39 @@ __export(exports_src, {
   parseDateSelector: () => parseDateSelector,
   parseCategory: () => parseCategory,
   parse: () => parse,
-  paragraph: () => import_ast8.paragraph,
+  paragraph: () => import_ast9.paragraph,
   normalizeQuery: () => normalizeQuery,
-  listItemSubList: () => import_ast8.listItemSubList,
-  listItemElements: () => import_ast8.listItemElements,
-  list: () => import_ast8.list,
-  link: () => import_ast8.link,
-  lineBreak: () => import_ast8.lineBreak,
-  italics: () => import_ast8.italics,
+  matchesListPagesSelectors: () => matchesListPagesSelectors,
+  listItemSubList: () => import_ast9.listItemSubList,
+  listItemElements: () => import_ast9.listItemElements,
+  list: () => import_ast9.list,
+  link: () => import_ast9.link,
+  lineBreak: () => import_ast9.lineBreak,
+  italics: () => import_ast9.italics,
   isTagCloudModule: () => isTagCloudModule,
   isListUsersModule: () => isListUsersModule2,
-  horizontalRule: () => import_ast8.horizontalRule,
-  heading: () => import_ast8.heading,
+  horizontalRule: () => import_ast9.horizontalRule,
+  heading: () => import_ast9.heading,
   extractListUsersVariables: () => extractListUsersVariables,
   extractIncludeReferences: () => extractIncludeReferences,
   extractDataRequirements: () => extractDataRequirements,
+  definePageData: () => definePageData,
   createToken: () => createToken,
-  createSettings: () => import_ast9.createSettings,
-  createPosition: () => import_ast8.createPosition,
-  createPoint: () => import_ast8.createPoint,
-  container: () => import_ast8.container,
+  createSettings: () => import_ast10.createSettings,
+  createPosition: () => import_ast9.createPosition,
+  createPoint: () => import_ast9.createPoint,
+  container: () => import_ast9.container,
   compileTemplate: () => compileTemplate,
   compileListUsersTemplate: () => compileListUsersTemplate,
-  bold: () => import_ast8.bold,
+  bold: () => import_ast9.bold,
   STYLE_SLOT_PREFIX: () => import_ast4.STYLE_SLOT_PREFIX,
   Parser: () => Parser,
   Lexer: () => Lexer,
-  DEFAULT_SETTINGS: () => import_ast9.DEFAULT_SETTINGS
+  DEFAULT_SETTINGS: () => import_ast10.DEFAULT_SETTINGS
 });
 module.exports = __toCommonJS(exports_src);
-var import_ast8 = require("@wdprlib/ast");
 var import_ast9 = require("@wdprlib/ast");
+var import_ast10 = require("@wdprlib/ast");
 
 // packages/parser/src/lexer/tokens.ts
 function createToken(type, value, position, lineStart = false) {
@@ -1445,7 +1447,7 @@ function parseNextBlock(ctx, skipWhitespace2, isAtEnd2) {
 }
 
 // packages/parser/src/parser/parse/context.ts
-var import_ast5 = require("@wdprlib/ast");
+var import_ast6 = require("@wdprlib/ast");
 
 // packages/parser/src/parser/rules/tokens.ts
 function currentToken(ctx) {
@@ -5919,6 +5921,60 @@ function resolveListPages(module2, data, compiledTemplate, parse) {
   const items = renderListPagesItems(module2, data, compiledTemplate, parse);
   return wrapListPagesResult(module2, items, parse);
 }
+// packages/parser/src/parser/rules/block/module/listpages/types/external-data.ts
+function definePageData(input) {
+  const separator = input.fullname.indexOf(":");
+  const category = separator === -1 ? "_default" : input.fullname.slice(0, separator);
+  const name = separator === -1 ? input.fullname : input.fullname.slice(separator + 1);
+  return {
+    ...input,
+    name: input.name ?? name,
+    category: input.category ?? category,
+    hiddenTags: input.hiddenTags ?? [],
+    children: input.children ?? 0,
+    comments: input.comments ?? 0,
+    size: input.size ?? 0,
+    rating: input.rating ?? 0,
+    ratingVotes: input.ratingVotes ?? 0,
+    revisions: input.revisions ?? 0
+  };
+}
+// packages/parser/src/parser/rules/block/module/listpages/selectors.ts
+function matchesListPagesSelectors(page, query, currentPage) {
+  return matchesCategory(page.category, query.category, currentPage.category) && matchesTags(page, query.tags, currentPage);
+}
+function matchesCategory(category, selector, currentCategory) {
+  if (!selector)
+    return category === currentCategory;
+  if (selector.exclude.includes(category))
+    return false;
+  const hasPositiveSelector = selector.all || selector.current || selector.include.length > 0;
+  return !hasPositiveSelector || selector.all || selector.current && category === currentCategory || selector.include.includes(category);
+}
+function matchesTags(page, selector, currentPage) {
+  if (!selector)
+    return true;
+  const allTags = new Set([...page.tags, ...page.hiddenTags]);
+  if (selector.all.some((tag) => !allTags.has(tag)))
+    return false;
+  if (selector.any.length > 0 && !selector.any.some((tag) => allTags.has(tag)))
+    return false;
+  if (selector.none.some((tag) => allTags.has(tag)))
+    return false;
+  if (selector.special === "none")
+    return allTags.size === 0;
+  const currentTags = new Set(currentPage.tags.filter((tag) => !tag.startsWith("_")));
+  if (selector.special === "same-visible") {
+    return page.tags.some((tag) => currentTags.has(tag));
+  }
+  if (selector.special === "same-all") {
+    return setsEqual(new Set(page.tags), currentTags);
+  }
+  return true;
+}
+function setsEqual(left, right) {
+  return left.size === right.size && [...left].every((value) => right.has(value));
+}
 // packages/parser/src/parser/rules/block/module/listpages/url-resolution/fields.ts
 var URL_RESOLVABLE_FIELDS = [
   { attr: "offset", queryKey: "offset", type: "number" },
@@ -6348,13 +6404,20 @@ var BASE_PLACEHOLDER_OPEN = "";
 var BASE_PLACEHOLDER_CLOSE = "";
 var RAW_BLOCK_OPEN_PATTERN = /\[\[\s*(code|html)\b[^\]]*\]\]/iy;
 function makeUniqueSentinels(source) {
-  let open = BASE_PLACEHOLDER_OPEN;
-  let close = BASE_PLACEHOLDER_CLOSE;
-  while (source.includes(open) || source.includes(close)) {
-    open += BASE_PLACEHOLDER_OPEN;
-    close += BASE_PLACEHOLDER_CLOSE;
+  let openRun = 0;
+  let closeRun = 0;
+  let longestOpenRun = 0;
+  let longestCloseRun = 0;
+  for (const char of source) {
+    openRun = char === BASE_PLACEHOLDER_OPEN ? openRun + 1 : 0;
+    closeRun = char === BASE_PLACEHOLDER_CLOSE ? closeRun + 1 : 0;
+    longestOpenRun = Math.max(longestOpenRun, openRun);
+    longestCloseRun = Math.max(longestCloseRun, closeRun);
   }
-  return { open, close };
+  return {
+    open: BASE_PLACEHOLDER_OPEN.repeat(longestOpenRun + 1),
+    close: BASE_PLACEHOLDER_CLOSE.repeat(longestCloseRun + 1)
+  };
 }
 function maskRawRegions(source, sentinels) {
   const placeholders = [];
@@ -6592,13 +6655,40 @@ function scanIncludeDirectives(source) {
 `, start);
     let depth = 0;
     let linkDepth = 0;
+    const nestedQuotes = [];
+    const nestedQuoteAllowed = [];
     let i = start;
     let closeEnd = -1;
     while (i < source.length) {
       const ch = source.charCodeAt(i);
       const next = source.charCodeAt(i + 1);
       const nextNext = source.charCodeAt(i + 2);
-      if (ch === OPEN_BRACKET && next === OPEN_BRACKET && nextNext === OPEN_BRACKET) {
+      if (ch === 10 || ch === 13) {
+        linkDepth = 0;
+        if (depth > 1) {
+          depth = 1;
+          nestedQuotes.length = 0;
+          nestedQuoteAllowed.length = 0;
+        }
+        i++;
+        continue;
+      }
+      const nestedQuote = nestedQuotes.at(-1);
+      if (nestedQuote !== undefined && nestedQuote !== null) {
+        if (ch === 92) {
+          i += 2;
+        } else {
+          if (ch === nestedQuote) {
+            nestedQuotes[nestedQuotes.length - 1] = null;
+            nestedQuoteAllowed[nestedQuoteAllowed.length - 1] = false;
+          }
+          i++;
+        }
+      } else if (nestedQuote === null && nestedQuoteAllowed.at(-1) === true && (ch === 34 || ch === 39)) {
+        nestedQuotes[nestedQuotes.length - 1] = ch;
+        nestedQuoteAllowed[nestedQuoteAllowed.length - 1] = false;
+        i++;
+      } else if (ch === OPEN_BRACKET && next === OPEN_BRACKET && nextNext === OPEN_BRACKET) {
         linkDepth++;
         i += 3;
       } else if (linkDepth > 0 && ch === CLOSE_BRACKET && next === CLOSE_BRACKET && nextNext === CLOSE_BRACKET) {
@@ -6607,10 +6697,26 @@ function scanIncludeDirectives(source) {
       } else if (linkDepth > 0) {
         i++;
       } else if (ch === OPEN_BRACKET && next === OPEN_BRACKET) {
+        if (nestedQuoteAllowed.length > 0) {
+          nestedQuoteAllowed[nestedQuoteAllowed.length - 1] = false;
+        }
+        if (depth > 0) {
+          nestedQuotes.push(null);
+          nestedQuoteAllowed.push(false);
+        }
         depth++;
         i += 2;
+      } else if (ch === CLOSE_BRACKET && next !== CLOSE_BRACKET && depth > 1) {
+        depth--;
+        nestedQuotes.pop();
+        nestedQuoteAllowed.pop();
+        i++;
       } else if (ch === CLOSE_BRACKET && next === CLOSE_BRACKET) {
         const closeStart = i;
+        if (depth > 1) {
+          nestedQuotes.pop();
+          nestedQuoteAllowed.pop();
+        }
         depth--;
         i += 2;
         if (depth <= 0) {
@@ -6627,6 +6733,13 @@ function scanIncludeDirectives(source) {
           }
         }
       } else {
+        if (nestedQuoteAllowed.length > 0) {
+          if (ch === 61) {
+            nestedQuoteAllowed[nestedQuoteAllowed.length - 1] = true;
+          } else if (ch !== 32 && ch !== 9) {
+            nestedQuoteAllowed[nestedQuoteAllowed.length - 1] = false;
+          }
+        }
         i++;
       }
     }
@@ -6812,13 +6925,13 @@ function expandIterativeWithTrace(source, fetcher, maxIterations) {
     reachedMaxIterations: iterations.length === maxIterations && scanIncludeDirectives(current2).length > 0
   };
 }
-async function expandIterativeAsyncWithTrace(source, fetcher, maxIterations) {
+async function expandIterativeAsyncWithTrace(source, fetcher, maxIterations, shouldDefer) {
   let current2 = source;
   const replacementCache = new Map;
   const dependencies = [];
   const iterations = [];
   for (let i = 0;i < maxIterations; i++) {
-    const expanded = await expandOneIterationAsyncWithTrace(current2, fetcher, replacementCache, i);
+    const expanded = await expandOneIterationAsyncWithTrace(current2, fetcher, replacementCache, i, shouldDefer);
     if (expanded === null)
       break;
     dependencies.push(...expanded.dependencies);
@@ -6835,7 +6948,7 @@ async function expandIterativeAsyncWithTrace(source, fetcher, maxIterations) {
     source: current2,
     dependencies,
     iterations,
-    reachedMaxIterations: iterations.length === maxIterations && scanIncludeDirectives(current2).length > 0
+    reachedMaxIterations: iterations.length === maxIterations && hasResolvableDirectives(current2, shouldDefer)
   };
 }
 function expandOneIteration(source, fetcher, replacementCache) {
@@ -6874,14 +6987,15 @@ function expandOneIterationWithTrace(source, fetcher, replacementCache, iteratio
     dependencies
   };
 }
-async function expandOneIterationAsyncWithTrace(source, fetcher, replacementCache, iteration) {
+async function expandOneIterationAsyncWithTrace(source, fetcher, replacementCache, iteration, shouldDefer) {
   if (!MAYBE_INCLUDE_PATTERN.test(source))
     return null;
   const directives = scanIncludeDirectives(source);
   if (directives.length === 0)
     return null;
   const references = directives.map(createIncludeReference);
-  const replacements = await Promise.all(directives.map(({ inner }) => replaceCachedAsync(inner, fetcher, replacementCache)));
+  const deferred = references.map((reference) => shouldDefer?.(reference) ?? false);
+  const replacements = await Promise.all(directives.map((directive, index) => deferred[index] ? Promise.resolve(source.slice(directive.start, directive.end)) : replaceCachedAsync(directive.inner, fetcher, replacementCache)));
   const parts = [];
   let lastPos = 0;
   for (let i = 0;i < directives.length; i++) {
@@ -6893,9 +7007,15 @@ async function expandOneIterationAsyncWithTrace(source, fetcher, replacementCach
   return {
     source: parts.join(""),
     references,
-    dependencies: references.map((reference) => ({ ...reference, iteration }))
+    dependencies: references.filter((_, index) => !deferred[index]).map((reference) => ({ ...reference, iteration }))
   };
 }
+function hasResolvableDirectives(source, shouldDefer) {
+  const directives = scanIncludeDirectives(source);
+  if (!shouldDefer)
+    return directives.length > 0;
+  return directives.some((directive) => !shouldDefer(createIncludeReference(directive)));
+}
 function replaceCached(inner, fetcher, cache) {
   const cached = cache.get(inner);
   if (cached !== undefined)
@@ -6951,6 +7071,19 @@ async function resolveIncludesAsyncWithTrace(source, fetcher, options) {
   const cachedFetcher = createCachedAsyncIncludeFetcher(fetcher, normalizePageKey);
   return expandIterativeAsyncWithTrace(source, cachedFetcher, maxIterations);
 }
+async function resolveIncludesAsyncWithTraceSelective(source, fetcher, shouldDefer, options) {
+  if (options?.settings && !options.settings.enablePageSyntax) {
+    return {
+      source,
+      dependencies: [],
+      iterations: [],
+      reachedMaxIterations: false
+    };
+  }
+  const maxIterations = options?.maxIterations ?? 10;
+  const cachedFetcher = createCachedAsyncIncludeFetcher(fetcher, normalizePageKey);
+  return expandIterativeAsyncWithTrace(source, cachedFetcher, maxIterations, shouldDefer);
+}
 function normalizePageKey(location) {
   const site = location.site ?? "";
   const page = location.page.toLowerCase();
@@ -8418,6 +8551,9 @@ var tabviewRule = {
   }
 };
 
+// packages/parser/src/parser/rules/block/include/index.ts
+var import_ast5 = require("@wdprlib/ast");
+
 // packages/parser/src/parser/rules/block/include/arguments.ts
 function collectIncludeArguments(ctx, startPos) {
   const argumentTokens = [];
@@ -8533,6 +8669,7 @@ var includeRule = {
     }
     pos++;
     consumed++;
+    const directiveEnd = pos;
     if (ctx.tokens[pos]?.type === "NEWLINE") {
       pos++;
       consumed++;
@@ -8540,6 +8677,20 @@ var includeRule = {
     if (!args.target) {
       return { success: false };
     }
+    const location = parsePageRef(args.target);
+    if (ctx.deferInclude?.(location)) {
+      const source = ctx.tokens.slice(ctx.pos, directiveEnd).map((token5) => token5.value).join("");
+      const elements = [];
+      const lines = source.split(`
+`);
+      for (let index = 0;index < lines.length; index++) {
+        if (index > 0)
+          elements.push(import_ast5.lineBreak());
+        if (lines[index] !== "")
+          elements.push(import_ast5.text(lines[index]));
+      }
+      return { success: true, elements: [import_ast5.paragraph(elements)], consumed };
+    }
     return {
       success: true,
       elements: [
@@ -8548,7 +8699,7 @@ var includeRule = {
           data: {
             "paragraph-safe": false,
             variables: parseVariables(args.argumentTokens),
-            location: parsePageRef(args.target),
+            location,
             elements: []
           }
         }
@@ -9816,9 +9967,9 @@ function parseGalleryItemLine(content) {
   const alt = attrs.get("alt") ?? null;
   return { source, link, alt, newWindow };
 }
-function parseItemAttrs(text) {
+function parseItemAttrs(text2) {
   const attrs = new Map;
-  const parts = text.trim().split('="');
+  const parts = text2.trim().split('="');
   let key = parts[0]?.trim() ?? "";
   for (let i = 1;i < parts.length; i++) {
     const val = parts[i] ?? "";
@@ -11880,11 +12031,11 @@ var guillemetRule = {
   startTokens: ["LEFT_DOUBLE_ANGLE", "RIGHT_DOUBLE_ANGLE"],
   parse(ctx) {
     const token5 = ctx.tokens[ctx.pos];
-    const text = guillemetText(token5?.type);
-    if (text) {
+    const text2 = guillemetText(token5?.type);
+    if (text2) {
       return {
         success: true,
-        elements: [{ element: "text", data: text }],
+        elements: [{ element: "text", data: text2 }],
         consumed: 1
       };
     }
@@ -12842,14 +12993,15 @@ var inlineRules = [
   textRule
 ];
 // packages/parser/src/parser/parse/context.ts
-function createParseContext(tokens, options = {}) {
+function createParseContext(tokens, options = {}, deferInclude) {
   return {
     tokens,
     pos: 0,
     version: options.version ?? "wikidot",
     trackPositions: options.trackPositions ?? true,
-    settings: options.settings ?? import_ast5.DEFAULT_SETTINGS,
+    settings: options.settings ?? import_ast6.DEFAULT_SETTINGS,
     appendImplicitFootnoteBlock: options.appendImplicitFootnoteBlock ?? true,
+    deferInclude,
     footnotes: [],
     tocEntries: [],
     codeBlocks: [],
@@ -13426,39 +13578,41 @@ class Parser {
     this.ctx = createParseContext(tokens, options);
   }
   parse() {
-    const children = [];
-    while (!this.isAtEnd()) {
-      const blocks = this.parseBlock();
-      children.push(...blocks);
-    }
-    return finalizeParseResult(this.ctx, children);
+    return parseContext(this.ctx);
   }
-  isAtEnd() {
-    return this.ctx.pos >= this.ctx.tokens.length || this.currentToken().type === "EOF";
-  }
-  currentToken() {
-    return this.ctx.tokens[this.ctx.pos] ?? this.eofToken();
-  }
-  eofToken() {
-    return {
-      type: "EOF",
-      value: "",
-      position: {
-        start: { line: 0, column: 0, offset: 0 },
-        end: { line: 0, column: 0, offset: 0 }
-      },
-      lineStart: false
-    };
-  }
-  skipWhitespace() {
-    while (this.currentToken().type === "WHITESPACE") {
-      this.ctx.pos++;
-    }
+}
+function parseTokensWithIncludeDeferral(tokens, options, deferInclude) {
+  return parseContext(createParseContext(tokens, options, deferInclude));
+}
+function parseContext(ctx) {
+  const children = [];
+  while (!isAtEnd3(ctx)) {
+    children.push(...parseBlock(ctx));
   }
-  parseBlock() {
-    return parseNextBlock(this.ctx, () => this.skipWhitespace(), () => this.isAtEnd());
+  return finalizeParseResult(ctx, children);
+}
+function isAtEnd3(ctx) {
+  return ctx.pos >= ctx.tokens.length || currentToken2(ctx).type === "EOF";
+}
+function currentToken2(ctx) {
+  return ctx.tokens[ctx.pos] ?? {
+    type: "EOF",
+    value: "",
+    position: {
+      start: { line: 0, column: 0, offset: 0 },
+      end: { line: 0, column: 0, offset: 0 }
+    },
+    lineStart: false
+  };
+}
+function skipWhitespace4(ctx) {
+  while (currentToken2(ctx).type === "WHITESPACE") {
+    ctx.pos++;
   }
 }
+function parseBlock(ctx) {
+  return parseNextBlock(ctx, () => skipWhitespace4(ctx), () => isAtEnd3(ctx));
+}
 
 // packages/parser/src/parser/parse/plain-non-ascii.ts
 var LARGE_PLAIN_TEXT_MIN_LENGTH = 1e5;
@@ -13466,8 +13620,8 @@ function parsePlainNonAsciiDocument(source) {
   if (!isPlainNonAsciiDocument(source)) {
     return null;
   }
-  const text = trimNewlineEdges(source);
-  const elements = text === "" ? [] : buildPlainParagraphs(text);
+  const text2 = trimNewlineEdges(source);
+  const elements = text2 === "" ? [] : buildPlainParagraphs(text2);
   elements.push({
     element: "footnote-block",
     data: { title: null, hide: false }
@@ -13487,8 +13641,8 @@ function parseLargePlainTextDocument(source) {
   if (source.length < LARGE_PLAIN_TEXT_MIN_LENGTH || hasWikitextSyntaxCandidate(source)) {
     return null;
   }
-  const text = trimNewlineEdges(source);
-  const elements = text === "" ? [] : buildPlainParagraphs(text);
+  const text2 = trimNewlineEdges(source);
+  const elements = text2 === "" ? [] : buildPlainParagraphs(text2);
   elements.push({
     element: "footnote-block",
     data: { title: null, hide: false }
@@ -13553,10 +13707,10 @@ function trimNewlineEdges(source) {
     end--;
   return start === 0 && end === source.length ? source : source.slice(start, end);
 }
-function buildPlainParagraphs(text) {
-  const paragraphs = text.indexOf(`
+function buildPlainParagraphs(text2) {
+  const paragraphs = text2.indexOf(`
 
-`) === -1 ? [text] : text.split(/\n{2,}/).filter((part) => part !== "");
+`) === -1 ? [text2] : text2.split(/\n{2,}/).filter((part) => part !== "");
   return paragraphs.map((paragraphText) => ({
     element: "container",
     data: {
@@ -13566,8 +13720,8 @@ function buildPlainParagraphs(text) {
     }
   }));
 }
-function buildPlainParagraphElements(text) {
-  const lines = text.split(`
+function buildPlainParagraphElements(text2) {
+  const lines = text2.split(`
 `);
   const elements = Array.from({ length: lines.length * 2 - 1 });
   let out = 0;
@@ -13581,32 +13735,32 @@ function buildPlainParagraphElements(text) {
 }
 
 // packages/parser/src/parser/preprocess/whitespace/detection.ts
-function needsWhitespaceSubstitution(text) {
-  if (text.length === 0)
+function needsWhitespaceSubstitution(text2) {
+  if (text2.length === 0)
     return false;
-  if (text[0] === `
-` || text[0] === " " || text[text.length - 1] === `
+  if (text2[0] === `
+` || text2[0] === " " || text2[text2.length - 1] === `
 `) {
     return true;
   }
-  return text.indexOf("\r") !== -1 || text.indexOf("\t") !== -1 || text.indexOf("\x00") !== -1 || text.indexOf(" ") !== -1 || text.indexOf(" ") !== -1 || text.indexOf("\\\n") !== -1 || text.indexOf(`
+  return text2.indexOf("\r") !== -1 || text2.indexOf("\t") !== -1 || text2.indexOf("\x00") !== -1 || text2.indexOf(" ") !== -1 || text2.indexOf(" ") !== -1 || text2.indexOf("\\\n") !== -1 || text2.indexOf(`
 
 
-`) !== -1 || text.indexOf(`
+`) !== -1 || text2.indexOf(`
  `) !== -1;
 }
-function mayContainWhitespaceOnlyLine(text) {
-  const first = text[0];
+function mayContainWhitespaceOnlyLine(text2) {
+  const first = text2[0];
   if (first === " " || first === "\t" || first === `
 ` || first === " " || first === " ") {
     return true;
   }
-  return text.indexOf(`
- `) !== -1 || text.indexOf(`
+  return text2.indexOf(`
+ `) !== -1 || text2.indexOf(`
 
-`) !== -1 || text.indexOf(`
-	`) !== -1 || text.indexOf(`
- `) !== -1 || text.indexOf(`
+`) !== -1 || text2.indexOf(`
+	`) !== -1 || text2.indexOf(`
+ `) !== -1 || text2.indexOf(`
  `) !== -1;
 }
 
@@ -13619,18 +13773,18 @@ var TABS = /\t/g;
 var NULL_CHARS = new RegExp(String.fromCharCode(0), "g");
 
 // packages/parser/src/parser/preprocess/whitespace/leading-spaces.ts
-function replaceLeadingSpaces(text) {
-  return text.replace(LEADING_NONSTANDARD_WHITESPACE, (match) => {
+function replaceLeadingSpaces(text2) {
+  return text2.replace(LEADING_NONSTANDARD_WHITESPACE, (match) => {
     return " ".repeat(match.length);
   });
 }
 
 // packages/parser/src/parser/preprocess/whitespace/index.ts
-function substitute(text) {
-  if (!needsWhitespaceSubstitution(text)) {
-    return text;
+function substitute(text2) {
+  if (!needsWhitespaceSubstitution(text2)) {
+    return text2;
   }
-  let result = text;
+  let result = text2;
   if (result.indexOf("\r") !== -1) {
     result = result.replace(DOS_MAC_NEWLINES, `
 `);
@@ -13660,21 +13814,21 @@ function substitute(text) {
   }
   return result;
 }
-function trimLeadingNewlines(text) {
+function trimLeadingNewlines(text2) {
   let index = 0;
-  while (text[index] === `
+  while (text2[index] === `
 `) {
     index++;
   }
-  return index === 0 ? text : text.slice(index);
+  return index === 0 ? text2 : text2.slice(index);
 }
-function trimTrailingNewlines(text) {
-  let end = text.length;
-  while (end > 0 && text[end - 1] === `
+function trimTrailingNewlines(text2) {
+  let end = text2.length;
+  while (end > 0 && text2[end - 1] === `
 `) {
     end--;
   }
-  return end === text.length ? text : text.slice(0, end);
+  return end === text2.length ? text2 : text2.slice(0, end);
 }
 
 // packages/parser/src/parser/preprocess/typography.ts
@@ -13684,50 +13838,50 @@ var LEFT_DOUBLE_QUOTE = "“";
 var RIGHT_DOUBLE_QUOTE = "”";
 var LOW_DOUBLE_QUOTE = "„";
 var ELLIPSIS = "…";
-function replaceExactEllipsisPattern(text, pattern) {
+function replaceExactEllipsisPattern(text2, pattern) {
   let searchFrom = 0;
   let result = "";
   let lastCopied = 0;
   const patternLength = pattern.length;
-  while (searchFrom < text.length) {
-    const index = text.indexOf(pattern, searchFrom);
+  while (searchFrom < text2.length) {
+    const index = text2.indexOf(pattern, searchFrom);
     if (index === -1)
       break;
-    const prev = index > 0 ? text[index - 1] : "";
-    const next = index + patternLength < text.length ? text[index + patternLength] : "";
+    const prev = index > 0 ? text2[index - 1] : "";
+    const next = index + patternLength < text2.length ? text2[index + patternLength] : "";
     if (prev !== "." && next !== ".") {
-      result += text.slice(lastCopied, index) + ELLIPSIS;
+      result += text2.slice(lastCopied, index) + ELLIPSIS;
       lastCopied = index + patternLength;
       searchFrom = lastCopied;
     } else {
       searchFrom = index + 1;
     }
   }
-  return lastCopied === 0 ? text : result + text.slice(lastCopied);
+  return lastCopied === 0 ? text2 : result + text2.slice(lastCopied);
 }
-function replaceDelimitedTypography(text, opener, closer, leftQuote, rightQuote) {
+function replaceDelimitedTypography(text2, opener, closer, leftQuote, rightQuote) {
   let searchFrom = 0;
   let result = "";
   let lastCopied = 0;
-  while (searchFrom < text.length) {
-    const openIndex = text.indexOf(opener, searchFrom);
+  while (searchFrom < text2.length) {
+    const openIndex = text2.indexOf(opener, searchFrom);
     if (openIndex === -1)
       break;
     const contentStart = openIndex + opener.length;
-    const closeIndex = text.indexOf(closer, contentStart);
+    const closeIndex = text2.indexOf(closer, contentStart);
     if (closeIndex === -1)
       break;
-    result += text.slice(lastCopied, openIndex);
+    result += text2.slice(lastCopied, openIndex);
     result += leftQuote;
-    result += text.slice(contentStart, closeIndex);
+    result += text2.slice(contentStart, closeIndex);
     result += rightQuote;
     lastCopied = closeIndex + closer.length;
     searchFrom = lastCopied;
   }
-  return lastCopied === 0 ? text : result + text.slice(lastCopied);
+  return lastCopied === 0 ? text2 : result + text2.slice(lastCopied);
 }
-function substitute2(text) {
-  let result = text;
+function substitute2(text2) {
+  let result = text2;
   if (result.includes("``") && result.includes("''")) {
     result = replaceDelimitedTypography(result, "``", "''", LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE);
   }
@@ -13747,37 +13901,13 @@ function substitute2(text) {
 }
 
 // packages/parser/src/parser/preprocess/index.ts
-function preprocess(text) {
-  let result = text;
+function preprocess(text2) {
+  let result = text2;
   result = substitute(result);
   result = substitute2(result);
   return result;
 }
 
-// packages/parser/src/parser/preprocess/expr/evaluate.ts
-var import_ast6 = require("@wdprlib/ast");
-function evaluateDirective(kind, match) {
-  if (kind === "expr") {
-    const result2 = import_ast6.evaluateExpression(match.head);
-    if (result2.success)
-      return import_ast6.formatExprValue(result2.value);
-    if (result2.error === "empty expression")
-      return "";
-    return "ERROR";
-  }
-  if (kind === "if") {
-    if (!match.hasPipe)
-      return "";
-    return import_ast6.isTruthy(match.head) ? match.thenText : match.elseText;
-  }
-  if (!match.hasPipe)
-    return "";
-  const result = import_ast6.evaluateExpression(match.head);
-  if (!result.success)
-    return "ERROR";
-  return result.value !== 0 && !Number.isNaN(result.value) ? match.thenText : match.elseText;
-}
-
 // packages/parser/src/parser/preprocess/expr/chars.ts
 function isWhitespace(ch) {
   return ch === " " || ch === "\t" || ch === `
@@ -13806,6 +13936,30 @@ function matchDirectiveKind(source, i) {
   return null;
 }
 
+// packages/parser/src/parser/preprocess/expr/evaluate.ts
+var import_ast7 = require("@wdprlib/ast");
+function evaluateDirective(kind, match) {
+  if (kind === "expr") {
+    const result2 = import_ast7.evaluateExpression(match.head);
+    if (result2.success)
+      return import_ast7.formatExprValue(result2.value);
+    if (result2.error === "empty expression")
+      return "";
+    return "ERROR";
+  }
+  if (kind === "if") {
+    if (!match.hasPipe)
+      return "";
+    return import_ast7.isTruthy(match.head) ? match.thenText : match.elseText;
+  }
+  if (!match.hasPipe)
+    return "";
+  const result = import_ast7.evaluateExpression(match.head);
+  if (!result.success)
+    return "ERROR";
+  return result.value !== 0 && !Number.isNaN(result.value) ? match.thenText : match.elseText;
+}
+
 // packages/parser/src/parser/preprocess/expr/parse.ts
 function tryParseInnermostDirective(source, start, kind) {
   const keywordLen = kind === "ifexpr" ? 6 : kind === "expr" ? 4 : 2;
@@ -13907,11 +14061,14 @@ function expandInnermost(source) {
 }
 
 // packages/parser/src/parser/preprocess/expr/index.ts
+var MAX_EXPR_NESTING = 64;
 function preprocessExpr(source) {
   if (!source.includes("[[#"))
     return source;
   const sentinels = makeUniqueSentinels(source);
   const { masked, placeholders } = maskRawRegions(source, sentinels);
+  if (exceedsExprNestingLimit(masked))
+    return source;
   const reduced = reduceExpr(masked);
   return restorePlaceholders(reduced, placeholders, sentinels);
 }
@@ -13926,6 +14083,26 @@ function reduceExpr(source) {
   }
   return current2;
 }
+function exceedsExprNestingLimit(source) {
+  const expressionStack = [];
+  let expressionDepth = 0;
+  for (let i = 0;i < source.length; i++) {
+    if (source.startsWith("[[", i)) {
+      const isExpression = matchDirectiveKind(source, i) !== null;
+      expressionStack.push(isExpression);
+      if (isExpression && ++expressionDepth > MAX_EXPR_NESTING)
+        return true;
+      i++;
+      continue;
+    }
+    if (source.startsWith("]]", i)) {
+      if (expressionStack.pop())
+        expressionDepth--;
+      i++;
+    }
+  }
+  return false;
+}
 
 // packages/parser/src/parser/parse/source.ts
 function prepareSourceForParse(source, options) {
@@ -13937,6 +14114,12 @@ function prepareSourceForParse(source, options) {
 // packages/parser/src/parser/parse/index.ts
 var COMPACT_TEXT_RUN_SOURCE_LENGTH = 1e5;
 function parse(source, options) {
+  return parseSource(source, options);
+}
+function parseWithIncludeDeferral(source, options, deferInclude) {
+  return parseSource(source, options, deferInclude);
+}
+function parseSource(source, options, deferInclude) {
   const plainResult = parsePlainNonAsciiDocument(source);
   if (plainResult) {
     return plainResult;
@@ -13950,10 +14133,10 @@ function parse(source, options) {
     trackPositions: options?.trackPositions,
     compactTextRuns: preprocessed.length >= COMPACT_TEXT_RUN_SOURCE_LENGTH
   });
-  return new Parser(tokens, options).parse();
+  return deferInclude ? parseTokensWithIncludeDeferral(tokens, options ?? {}, deferInclude) : new Parser(tokens, options).parse();
 }
 // packages/parser/src/pipeline/process.ts
-var import_ast7 = require("@wdprlib/ast");
+var import_ast8 = require("@wdprlib/ast");
 
 // packages/parser/src/parser/rules/block/module/resolution/resolve-async.ts
 async function resolveModulesWithAsyncParse(ast, dataProvider, options) {
@@ -14129,52 +14312,94 @@ async function resolveElementChildren(element, context, state) {
 }
 
 // packages/parser/src/pipeline/process.ts
+var DEFAULT_MODULE_MAX_PASSES = 5;
+var PIPELINE_DIAGNOSTIC_POSITION = {
+  start: { line: 1, column: 1, offset: 0 },
+  end: { line: 1, column: 1, offset: 0 }
+};
 async function processWikitext(source, options) {
-  const settings = options.settings ?? import_ast7.DEFAULT_SETTINGS;
+  const settings = options.settings ?? import_ast8.DEFAULT_SETTINGS;
   const callbackContext = {
     page: options.page,
     settings
   };
   const dependencies = [];
+  const diagnostics = [];
   const fetchInclude = createRequestIncludeFetcher(options.dataProvider?.fetchInclude ? (pageRef) => options.dataProvider.fetchInclude(pageRef, callbackContext) : undefined);
   const resolveSource = async (input) => {
-    if (!fetchInclude)
-      return input;
-    const resolution = await resolveIncludesAsyncWithTrace(input, fetchInclude, {
-      maxIterations: options.includeMaxIterations,
-      settings
-    });
-    dependencies.push(...resolution.dependencies);
-    return resolution.source;
+    let expanded = input;
+    if (fetchInclude) {
+      const resolution = await resolveIncludesAsyncWithTraceSelective(input, fetchInclude, (reference) => isCurrentPageInclude(reference.location, options.page), {
+        maxIterations: options.includeMaxIterations,
+        settings
+      });
+      dependencies.push(...resolution.dependencies);
+      if (resolution.reachedMaxIterations) {
+        diagnostics.push(createLimitDiagnostic("include-resolution-limit", `Include expansion stopped after ${options.includeMaxIterations ?? 10} iterations.`));
+      }
+      expanded = resolution.source;
+    }
+    return expanded;
   };
-  const expandedSource = await resolveSource(source);
-  const initial = parse(expandedSource, {
-    settings,
-    pageTags: options.page.tags,
-    appendImplicitFootnoteBlock: false
-  });
-  const extraction = extractDataRequirements(initial.ast);
-  const dataProvider = createModuleDataProvider(options, callbackContext);
-  const resolved = await resolveModulesWithAsyncParse(initial.ast, dataProvider, {
-    parse: async (fragmentSource) => parse(await resolveSource(fragmentSource), {
+  const parseSource2 = async (input) => {
+    const expanded = await resolveSource(input);
+    return parseWithIncludeDeferral(expanded, {
       settings,
       pageTags: options.page.tags,
       appendImplicitFootnoteBlock: false
-    }),
-    compiledListPagesTemplates: extraction.compiledListPagesTemplates,
-    compiledListUsersTemplates: extraction.compiledListUsersTemplates,
-    requirements: extraction.requirements,
-    urlPath: options.page.urlPath,
-    pageTags: options.page.tags
-  });
+    }, (location) => isCurrentPageInclude(location, options.page));
+  };
+  const initial = await parseSource2(source);
+  diagnostics.push(...initial.diagnostics);
+  const dataProvider = createModuleDataProvider(options, callbackContext);
+  const parseFragment = parseSource2;
+  let ast = initial.ast;
+  for (let pass = 0;pass < DEFAULT_MODULE_MAX_PASSES; pass++) {
+    const extraction = extractDataRequirements(ast);
+    if (pass > 0 && !hasResolvableRequirements(extraction.requirements, options.dataProvider)) {
+      break;
+    }
+    const resolved = await resolveModulesWithAsyncParse(ast, dataProvider, {
+      parse: parseFragment,
+      compiledListPagesTemplates: extraction.compiledListPagesTemplates,
+      compiledListUsersTemplates: extraction.compiledListUsersTemplates,
+      requirements: extraction.requirements,
+      urlPath: options.page.urlPath,
+      pageTags: options.page.tags
+    });
+    ast = resolved.ast;
+    diagnostics.push(...resolved.diagnostics);
+  }
+  if (hasResolvableRequirements(extractDataRequirements(ast).requirements, options.dataProvider)) {
+    diagnostics.push(createLimitDiagnostic("module-resolution-limit", `Module resolution stopped after ${DEFAULT_MODULE_MAX_PASSES} passes.`));
+  }
   return {
-    ast: resolved.ast,
+    ast,
     page: options.page,
     settings,
-    diagnostics: [...initial.diagnostics, ...resolved.diagnostics],
+    diagnostics,
     dependencies
   };
 }
+function isCurrentPageInclude(location, page) {
+  if (location.site !== null) {
+    if (!page.site || location.site.toLowerCase() !== page.site.toLowerCase())
+      return false;
+  }
+  const target = location.page.toLowerCase();
+  return target === page.fullName.toLowerCase() || target === page.unixName?.toLowerCase();
+}
+function hasResolvableRequirements(requirements, provider) {
+  return Boolean(provider?.fetchListPages && requirements.listPages.length > 0 || provider?.fetchListUsers && requirements.listUsers.length > 0 || provider?.fetchTagCloud && requirements.tagCloud.length > 0);
+}
+function createLimitDiagnostic(code, message) {
+  return {
+    severity: "warning",
+    code,
+    message,
+    position: PIPELINE_DIAGNOSTIC_POSITION
+  };
+}
 function createModuleDataProvider(options, context) {
   const provider = options.dataProvider;
   return {