@wdprlib/parser 5.0.0 → 5.1.2

package/dist/index.js

@@ -2,13 +2,13 @@
 import {
   createPoint,
   createPosition,
-  text,
+  text as text2,
   container,
-  paragraph,
+  paragraph as paragraph2,
   bold,
   italics,
   heading,
-  lineBreak,
+  lineBreak as lineBreak2,
   horizontalRule,
   link,
   list,
@@ -6590,13 +6590,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) {
@@ -6605,10 +6632,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) {
@@ -6625,6 +6668,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++;
       }
     }
@@ -6810,13 +6860,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);
@@ -6833,7 +6883,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) {
@@ -6872,14 +6922,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++) {
@@ -6891,9 +6942,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)
@@ -6949,6 +7006,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();
@@ -8419,6 +8489,9 @@ var tabviewRule = {
   }
 };
 
+// packages/parser/src/parser/rules/block/include/index.ts
+import { lineBreak, paragraph, text } from "@wdprlib/ast";
+
 // packages/parser/src/parser/rules/block/include/arguments.ts
 function collectIncludeArguments(ctx, startPos) {
   const argumentTokens = [];
@@ -8534,6 +8607,7 @@ var includeRule = {
     }
     pos++;
     consumed++;
+    const directiveEnd = pos;
     if (ctx.tokens[pos]?.type === "NEWLINE") {
       pos++;
       consumed++;
@@ -8541,6 +8615,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(lineBreak());
+        if (lines[index] !== "")
+          elements.push(text(lines[index]));
+      }
+      return { success: true, elements: [paragraph(elements)], consumed };
+    }
     return {
       success: true,
       elements: [
@@ -8549,7 +8637,7 @@ var includeRule = {
           data: {
             "paragraph-safe": false,
             variables: parseVariables(args.argumentTokens),
-            location: parsePageRef(args.target),
+            location,
             elements: []
           }
         }
@@ -9817,9 +9905,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] ?? "";
@@ -11881,11 +11969,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
       };
     }
@@ -12843,7 +12931,7 @@ var inlineRules = [
   textRule
 ];
 // packages/parser/src/parser/parse/context.ts
-function createParseContext(tokens, options = {}) {
+function createParseContext(tokens, options = {}, deferInclude) {
   return {
     tokens,
     pos: 0,
@@ -12851,6 +12939,7 @@ function createParseContext(tokens, options = {}) {
     trackPositions: options.trackPositions ?? true,
     settings: options.settings ?? DEFAULT_SETTINGS,
     appendImplicitFootnoteBlock: options.appendImplicitFootnoteBlock ?? true,
+    deferInclude,
     footnotes: [],
     tocEntries: [],
     codeBlocks: [],
@@ -13427,39 +13516,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;
@@ -13467,8 +13558,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 }
@@ -13488,8 +13579,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 }
@@ -13554,10 +13645,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: {
@@ -13567,8 +13658,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;
@@ -13582,32 +13673,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;
 }
 
@@ -13620,18 +13711,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, `
 `);
@@ -13661,21 +13752,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
@@ -13685,50 +13776,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);
   }
@@ -13748,8 +13839,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;
@@ -13961,6 +14052,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;
@@ -13974,7 +14071,7 @@ 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
 import {
@@ -14170,31 +14267,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);
@@ -14223,6 +14321,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);
 }
@@ -14259,7 +14365,7 @@ function createRequestIncludeFetcher(fetcher) {
 }
 export {
   tokenize,
-  text,
+  text2 as text,
   resolveTagCloud,
   resolveModules,
   resolveListUsers,
@@ -14276,14 +14382,14 @@ export {
   parseDateSelector,
   parseCategory,
   parse,
-  paragraph,
+  paragraph2 as paragraph,
   normalizeQuery,
   matchesListPagesSelectors,
   listItemSubList,
   listItemElements,
   list,
   link,
-  lineBreak,
+  lineBreak2 as lineBreak,
   italics,
   isTagCloudModule,
   isListUsersModule2 as isListUsersModule,