@wdprlib/parser 5.0.0 → 5.1.2

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,39 +48,39 @@ __export(exports_src, {
   parseDateSelector: () => parseDateSelector,
   parseCategory: () => parseCategory,
   parse: () => parse,
-  paragraph: () => import_ast8.paragraph,
+  paragraph: () => import_ast9.paragraph,
   normalizeQuery: () => normalizeQuery,
   matchesListPagesSelectors: () => matchesListPagesSelectors,
-  listItemSubList: () => import_ast8.listItemSubList,
-  listItemElements: () => import_ast8.listItemElements,
-  list: () => import_ast8.list,
-  link: () => import_ast8.link,
-  lineBreak: () => import_ast8.lineBreak,
-  italics: () => import_ast8.italics,
+  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) {
@@ -1447,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) {
@@ -6655,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) {
@@ -6670,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) {
@@ -6690,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++;
       }
     }
@@ -6875,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);
@@ -6898,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) {
@@ -6937,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++) {
@@ -6956,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)
@@ -7014,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();
@@ -8481,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 = [];
@@ -8596,6 +8669,7 @@ var includeRule = {
     }
     pos++;
     consumed++;
+    const directiveEnd = pos;
     if (ctx.tokens[pos]?.type === "NEWLINE") {
       pos++;
       consumed++;
@@ -8603,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: [
@@ -8611,7 +8699,7 @@ var includeRule = {
           data: {
             "paragraph-safe": false,
             variables: parseVariables(args.argumentTokens),
-            location: parsePageRef(args.target),
+            location,
             elements: []
           }
         }
@@ -9879,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] ?? "";
@@ -11943,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
       };
     }
@@ -12905,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: [],
@@ -13489,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;
@@ -13529,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 }
@@ -13550,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 }
@@ -13616,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: {
@@ -13629,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;
@@ -13644,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;
 }
 
@@ -13682,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, `
 `);
@@ -13723,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
@@ -13747,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);
   }
@@ -13810,8 +13901,8 @@ 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;
@@ -13846,12 +13937,12 @@ function matchDirectiveKind(source, i) {
 }
 
 // packages/parser/src/parser/preprocess/expr/evaluate.ts
-var import_ast6 = require("@wdprlib/ast");
+var import_ast7 = require("@wdprlib/ast");
 function evaluateDirective(kind, match) {
   if (kind === "expr") {
-    const result2 = import_ast6.evaluateExpression(match.head);
+    const result2 = import_ast7.evaluateExpression(match.head);
     if (result2.success)
-      return import_ast6.formatExprValue(result2.value);
+      return import_ast7.formatExprValue(result2.value);
     if (result2.error === "empty expression")
       return "";
     return "ERROR";
@@ -13859,11 +13950,11 @@ function evaluateDirective(kind, match) {
   if (kind === "if") {
     if (!match.hasPipe)
       return "";
-    return import_ast6.isTruthy(match.head) ? match.thenText : match.elseText;
+    return import_ast7.isTruthy(match.head) ? match.thenText : match.elseText;
   }
   if (!match.hasPipe)
     return "";
-  const result = import_ast6.evaluateExpression(match.head);
+  const result = import_ast7.evaluateExpression(match.head);
   if (!result.success)
     return "ERROR";
   return result.value !== 0 && !Number.isNaN(result.value) ? match.thenText : match.elseText;
@@ -14023,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;
@@ -14036,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) {
@@ -14221,7 +14318,7 @@ var PIPELINE_DIAGNOSTIC_POSITION = {
   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
@@ -14230,31 +14327,32 @@ async function processWikitext(source, options) {
   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);
-    if (resolution.reachedMaxIterations) {
-      diagnostics.push(createLimitDiagnostic("include-resolution-limit", `Include expansion stopped after ${options.includeMaxIterations ?? 10} iterations.`));
+    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 resolution.source;
+    return expanded;
   };
-  const expandedSource = await resolveSource(source);
-  const initial = parse(expandedSource, {
-    settings,
-    pageTags: options.page.tags,
-    appendImplicitFootnoteBlock: false
-  });
+  const parseSource2 = async (input) => {
+    const expanded = await resolveSource(input);
+    return parseWithIncludeDeferral(expanded, {
+      settings,
+      pageTags: options.page.tags,
+      appendImplicitFootnoteBlock: false
+    }, (location) => isCurrentPageInclude(location, options.page));
+  };
+  const initial = await parseSource2(source);
   diagnostics.push(...initial.diagnostics);
   const dataProvider = createModuleDataProvider(options, callbackContext);
-  const parseFragment = async (fragmentSource) => parse(await resolveSource(fragmentSource), {
-    settings,
-    pageTags: options.page.tags,
-    appendImplicitFootnoteBlock: false
-  });
+  const parseFragment = parseSource2;
   let ast = initial.ast;
   for (let pass = 0;pass < DEFAULT_MODULE_MAX_PASSES; pass++) {
     const extraction = extractDataRequirements(ast);
@@ -14283,6 +14381,14 @@ async function processWikitext(source, options) {
     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);
 }