@wdprlib/parser 4.3.0 → 4.4.0

package/dist/index.cjs

@@ -31,13 +31,15 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   tokenize: () => tokenize,
-  text: () => import_ast6.text,
+  text: () => import_ast8.text,
   resolveTagCloud: () => resolveTagCloud,
   resolveModules: () => resolveModules,
   resolveListUsers: () => resolveListUsers,
   resolveIncludesWithTrace: () => resolveIncludesWithTrace,
+  resolveIncludesAsyncWithTrace: () => resolveIncludesAsyncWithTrace,
   resolveIncludesAsync: () => resolveIncludesAsync,
   resolveIncludes: () => resolveIncludes,
+  processWikitext: () => processWikitext,
   preprocessIftags: () => preprocessIftags,
   parseTags: () => parseTags,
   parseParent: () => parseParent,
@@ -46,37 +48,37 @@ __export(exports_src, {
   parseDateSelector: () => parseDateSelector,
   parseCategory: () => parseCategory,
   parse: () => parse,
-  paragraph: () => import_ast6.paragraph,
+  paragraph: () => import_ast8.paragraph,
   normalizeQuery: () => normalizeQuery,
-  listItemSubList: () => import_ast6.listItemSubList,
-  listItemElements: () => import_ast6.listItemElements,
-  list: () => import_ast6.list,
-  link: () => import_ast6.link,
-  lineBreak: () => import_ast6.lineBreak,
-  italics: () => import_ast6.italics,
+  listItemSubList: () => import_ast8.listItemSubList,
+  listItemElements: () => import_ast8.listItemElements,
+  list: () => import_ast8.list,
+  link: () => import_ast8.link,
+  lineBreak: () => import_ast8.lineBreak,
+  italics: () => import_ast8.italics,
   isTagCloudModule: () => isTagCloudModule,
   isListUsersModule: () => isListUsersModule2,
-  horizontalRule: () => import_ast6.horizontalRule,
-  heading: () => import_ast6.heading,
+  horizontalRule: () => import_ast8.horizontalRule,
+  heading: () => import_ast8.heading,
   extractListUsersVariables: () => extractListUsersVariables,
   extractIncludeReferences: () => extractIncludeReferences,
   extractDataRequirements: () => extractDataRequirements,
   createToken: () => createToken,
-  createSettings: () => import_ast7.createSettings,
-  createPosition: () => import_ast6.createPosition,
-  createPoint: () => import_ast6.createPoint,
-  container: () => import_ast6.container,
+  createSettings: () => import_ast9.createSettings,
+  createPosition: () => import_ast8.createPosition,
+  createPoint: () => import_ast8.createPoint,
+  container: () => import_ast8.container,
   compileTemplate: () => compileTemplate,
   compileListUsersTemplate: () => compileListUsersTemplate,
-  bold: () => import_ast6.bold,
-  STYLE_SLOT_PREFIX: () => import_ast3.STYLE_SLOT_PREFIX,
+  bold: () => import_ast8.bold,
+  STYLE_SLOT_PREFIX: () => import_ast4.STYLE_SLOT_PREFIX,
   Parser: () => Parser,
   Lexer: () => Lexer,
-  DEFAULT_SETTINGS: () => import_ast7.DEFAULT_SETTINGS
+  DEFAULT_SETTINGS: () => import_ast9.DEFAULT_SETTINGS
 });
 module.exports = __toCommonJS(exports_src);
-var import_ast6 = require("@wdprlib/ast");
-var import_ast7 = require("@wdprlib/ast");
+var import_ast8 = require("@wdprlib/ast");
+var import_ast9 = require("@wdprlib/ast");
 
 // packages/parser/src/lexer/tokens.ts
 function createToken(type, value, position, lineStart = false) {
@@ -1443,7 +1445,7 @@ function parseNextBlock(ctx, skipWhitespace2, isAtEnd2) {
 }
 
 // packages/parser/src/parser/parse/context.ts
-var import_ast4 = require("@wdprlib/ast");
+var import_ast5 = require("@wdprlib/ast");
 
 // packages/parser/src/parser/rules/tokens.ts
 function currentToken(ctx) {
@@ -5843,6 +5845,11 @@ function extractDataRequirements(ast) {
   });
   return result;
 }
+// packages/parser/src/parser/rules/block/module/types.ts
+function getModuleParseAst(result) {
+  return "ast" in result ? result.ast : result;
+}
+
 // packages/parser/src/parser/rules/block/module/listpages/resolution/items.ts
 function renderListPagesItems(module2, data, compiledTemplate, parse) {
   const items = [];
@@ -5857,7 +5864,7 @@ function renderListPagesItems(module2, data, compiledTemplate, parse) {
       limit: module2.limit,
       site: data.site
     };
-    const itemAst = parse(compiledTemplate(ctx));
+    const itemAst = getModuleParseAst(parse(compiledTemplate(ctx)));
     if (module2.separate) {
       items.push({
         element: "container",
@@ -5881,12 +5888,12 @@ function wrapListPagesResult(module2, items, parse) {
   }
   const result = [];
   if (module2["prepend-line"] && !module2.separate) {
-    const prependAst = parse(module2["prepend-line"]);
+    const prependAst = getModuleParseAst(parse(module2["prepend-line"]));
     result.push(...prependAst.elements);
   }
   result.push(...items);
   if (module2["append-line"] && !module2.separate) {
-    const appendAst = parse(module2["append-line"]);
+    const appendAst = getModuleParseAst(parse(module2["append-line"]));
     result.push(...appendAst.elements);
   }
   if (module2.wrapper) {
@@ -6805,16 +6812,31 @@ function expandIterativeWithTrace(source, fetcher, maxIterations) {
     reachedMaxIterations: iterations.length === maxIterations && scanIncludeDirectives(current2).length > 0
   };
 }
-async function expandIterativeAsync(source, fetcher, maxIterations) {
+async function expandIterativeAsyncWithTrace(source, fetcher, maxIterations) {
   let current2 = source;
   const replacementCache = new Map;
+  const dependencies = [];
+  const iterations = [];
   for (let i = 0;i < maxIterations; i++) {
-    const expanded = await expandOneIterationAsync(current2, fetcher, replacementCache);
-    if (expanded === null || expanded === current2)
+    const expanded = await expandOneIterationAsyncWithTrace(current2, fetcher, replacementCache, i);
+    if (expanded === null)
       break;
-    current2 = expanded;
+    dependencies.push(...expanded.dependencies);
+    iterations.push({
+      iteration: i,
+      directives: expanded.references,
+      changed: expanded.source !== current2
+    });
+    if (expanded.source === current2)
+      break;
+    current2 = expanded.source;
   }
-  return current2;
+  return {
+    source: current2,
+    dependencies,
+    iterations,
+    reachedMaxIterations: iterations.length === maxIterations && scanIncludeDirectives(current2).length > 0
+  };
 }
 function expandOneIteration(source, fetcher, replacementCache) {
   if (!MAYBE_INCLUDE_PATTERN.test(source))
@@ -6852,12 +6874,13 @@ function expandOneIterationWithTrace(source, fetcher, replacementCache, iteratio
     dependencies
   };
 }
-async function expandOneIterationAsync(source, fetcher, replacementCache) {
+async function expandOneIterationAsyncWithTrace(source, fetcher, replacementCache, iteration) {
   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 parts = [];
   let lastPos = 0;
@@ -6867,7 +6890,11 @@ async function expandOneIterationAsync(source, fetcher, replacementCache) {
     lastPos = end;
   }
   parts.push(source.slice(lastPos));
-  return parts.join("");
+  return {
+    source: parts.join(""),
+    references,
+    dependencies: references.map((reference) => ({ ...reference, iteration }))
+  };
 }
 function replaceCached(inner, fetcher, cache) {
   const cached = cache.get(inner);
@@ -6909,12 +6936,20 @@ function resolveIncludesWithTrace(source, fetcher, options) {
   return expandIterativeWithTrace(source, cachedFetcher, maxIterations);
 }
 async function resolveIncludesAsync(source, fetcher, options) {
+  return (await resolveIncludesAsyncWithTrace(source, fetcher, options)).source;
+}
+async function resolveIncludesAsyncWithTrace(source, fetcher, options) {
   if (options?.settings && !options.settings.enablePageSyntax) {
-    return source;
+    return {
+      source,
+      dependencies: [],
+      iterations: [],
+      reachedMaxIterations: false
+    };
   }
   const maxIterations = options?.maxIterations ?? 10;
   const cachedFetcher = createCachedAsyncIncludeFetcher(fetcher, normalizePageKey);
-  return expandIterativeAsync(source, cachedFetcher, maxIterations);
+  return expandIterativeAsyncWithTrace(source, cachedFetcher, maxIterations);
 }
 function normalizePageKey(location) {
   const site = location.site ?? "";
@@ -6928,7 +6963,7 @@ function isListUsersModule2(module2) {
 function resolveListUsers(_module, data, compiledTemplate, parse) {
   const ctx = { user: data.user };
   const substituted = compiledTemplate(ctx);
-  const itemAst = parse(substituted);
+  const itemAst = getModuleParseAst(parse(substituted));
   return itemAst.elements;
 }
 // packages/parser/src/parser/rules/block/module/resolution/data-maps.ts
@@ -7081,6 +7116,117 @@ function countDynamicModules(elements) {
   return counts;
 }
 
+// packages/parser/src/parser/rules/block/module/resolution/styles.ts
+var import_ast2 = require("@wdprlib/ast");
+function collectStyles(elements, ignoredAnchors = new WeakSet) {
+  const styles = [];
+  const anchoredStyles = [];
+  const anchors = [];
+  const usedSlots = collectExistingStyleSlots(elements);
+  const ctx = { nextSlotId: 0, usedSlots };
+  const filtered = collectStylesFromElements(elements, styles, anchoredStyles, anchors, ignoredAnchors, ctx);
+  return { elements: filtered, styles, anchoredStyles, anchors };
+}
+function mergeCollectedStyles(existing, collected, resolvedSlots = new Map, anchoredStyles = []) {
+  const unanchoredPrevious = [...existing ?? []];
+  for (const style of anchoredStyles)
+    removeFirst(unanchoredPrevious, style);
+  for (const style of collected) {
+    if (isStyleSlotMarker(style))
+      removeFirst(unanchoredPrevious, style);
+  }
+  const merged = unanchoredPrevious.filter((style) => !isStyleSlotMarker(style));
+  for (const style of collected) {
+    if (isStyleSlotMarker(style))
+      appendStyleSlot(merged, style, resolvedSlots);
+    else
+      merged.push(style);
+  }
+  return merged;
+}
+function isStyleSlotMarker(style) {
+  return style.startsWith(import_ast2.STYLE_SLOT_PREFIX);
+}
+function createStyleSlotMarker(slotId) {
+  return `${import_ast2.STYLE_SLOT_PREFIX}${slotId}`;
+}
+function getStyleSlotId(data) {
+  const slotId = data._styleSlot;
+  return Number.isSafeInteger(slotId) && slotId >= 0 ? slotId : undefined;
+}
+function removeFirst(values, value) {
+  const index = values.indexOf(value);
+  if (index >= 0)
+    values.splice(index, 1);
+}
+function appendStyleSlot(target, marker, resolvedSlots) {
+  const slotId = Number(marker.slice(import_ast2.STYLE_SLOT_PREFIX.length));
+  const replacement = resolvedSlots.get(slotId);
+  if (replacement)
+    target.push(...replacement);
+  else
+    target.push(marker);
+}
+function collectExistingStyleSlots(elements) {
+  const slots = new Set;
+  walkElements(elements, (element) => {
+    if (element.element !== "if-tags")
+      return;
+    const slotId = getStyleSlotId(element.data);
+    if (slotId !== undefined)
+      slots.add(slotId);
+  });
+  return slots;
+}
+function allocateStyleSlot(ctx) {
+  while (ctx.usedSlots.has(ctx.nextSlotId))
+    ctx.nextSlotId++;
+  const slotId = ctx.nextSlotId++;
+  ctx.usedSlots.add(slotId);
+  return slotId;
+}
+function collectStylesFromElements(elements, styles, anchoredStyles, anchors, ignoredAnchors, ctx) {
+  const result = [];
+  for (const element of elements) {
+    if (element.element === "style") {
+      const css = element.data;
+      if (css.startsWith(import_ast2.STYLE_SLOT_PREFIX)) {
+        styles.push(css);
+        continue;
+      }
+      if (css.startsWith(import_ast2.STYLE_ANCHOR_PREFIX)) {
+        anchors.push(element);
+        if (ignoredAnchors.has(element)) {
+          result.push(element);
+          continue;
+        }
+        const anchoredCss = css.slice(import_ast2.STYLE_ANCHOR_PREFIX.length);
+        styles.push(anchoredCss);
+        anchoredStyles.push(anchoredCss);
+        result.push(element);
+        continue;
+      }
+      styles.push(css);
+      const anchor = { element: "style", data: `${import_ast2.STYLE_ANCHOR_PREFIX}${css}` };
+      anchors.push(anchor);
+      result.push(anchor);
+      continue;
+    }
+    if (element.element === "if-tags") {
+      const slotId = getStyleSlotId(element.data) ?? allocateStyleSlot(ctx);
+      styles.push(createStyleSlotMarker(slotId));
+      const data = { ...element.data, _styleSlot: slotId };
+      result.push({
+        element: "if-tags",
+        data
+      });
+      continue;
+    }
+    result.push(mapElementChildren(element, (children) => collectStylesFromElements(children, styles, anchoredStyles, anchors, ignoredAnchors, ctx)));
+  }
+  return result;
+}
+
 // packages/parser/src/parser/rules/block/module/resolution/walk-resolve.ts
 function walkAndResolve(elements, ctx) {
   const result = [];
@@ -7103,6 +7249,7 @@ function walkAndResolve(elements, ctx) {
     if (isIfTagsElement(element)) {
       const ifTagsData = element.data;
       const resolveResult = resolveIfTags(ifTagsData, ctx.pageTags);
+      const styleSlotId = getStyleSlotId(ifTagsData);
       if (resolveResult.evaluated) {
         if (resolveResult.matched) {
           const childResult = walkAndResolve(ifTagsData.elements, {
@@ -7111,11 +7258,23 @@ function walkAndResolve(elements, ctx) {
             listUsersIdCounter: listUsersId,
             tagCloudIdCounter: tagCloudId
           });
-          result.push(...childResult.elements);
+          if (styleSlotId === undefined) {
+            result.push(...childResult.elements);
+          } else {
+            const collected = collectStyles(childResult.elements);
+            ctx.resolvedStyleSlots.set(styleSlotId, collected.styles);
+            for (const anchor of collected.anchors)
+              ctx.routedStyleAnchors.add(anchor);
+            result.push({ element: "style", data: createStyleSlotMarker(styleSlotId) }, ...collected.elements);
+          }
           listPagesId = childResult.nextListPagesId;
           listUsersId = childResult.nextListUsersId;
           tagCloudId = childResult.nextTagCloudId;
         } else {
+          if (styleSlotId !== undefined) {
+            ctx.resolvedStyleSlots.set(styleSlotId, []);
+            result.push({ element: "style", data: createStyleSlotMarker(styleSlotId) });
+          }
           const counts = countDynamicModules(ifTagsData.elements);
           listPagesId += counts.listPagesId;
           listUsersId += counts.listUsersId;
@@ -7170,44 +7329,358 @@ function walkAndResolve(elements, ctx) {
   };
 }
 
-// packages/parser/src/parser/rules/block/module/resolution/styles.ts
-var import_ast2 = require("@wdprlib/ast");
-function collectStyles(elements) {
-  const styles = [];
-  const ctx = { nextSlotId: 0 };
-  const filtered = collectStylesFromElements(elements, styles, ctx);
-  return { elements: filtered, styles };
+// packages/parser/src/parser/rules/block/module/resolution/document.ts
+var import_ast3 = require("@wdprlib/ast");
+
+// packages/parser/src/parser/toc.ts
+class TocIndexer {
+  index = 0;
+  next() {
+    return this.index++;
+  }
+}
+function buildTocList(indexer, items) {
+  const listItems = items.map((item) => buildTocListItem(indexer, item));
+  return {
+    element: "list",
+    data: {
+      type: "bullet",
+      attributes: {},
+      items: listItems
+    }
+  };
+}
+function buildTocListItem(indexer, item) {
+  if (item.kind === "list") {
+    return {
+      "item-type": "sub-list",
+      element: "list",
+      data: {
+        type: "bullet",
+        attributes: {},
+        items: item.children.map((child) => buildTocListItem(indexer, child))
+      }
+    };
+  }
+  const anchor = `#toc${indexer.next()}`;
+  const linkElement = {
+    element: "link",
+    data: {
+      type: "table-of-contents",
+      link: anchor,
+      extra: null,
+      label: { text: item.value },
+      target: null
+    }
+  };
+  return {
+    "item-type": "elements",
+    attributes: {},
+    elements: [linkElement]
+  };
+}
+function buildTableOfContents(entries) {
+  if (entries.length === 0) {
+    return [];
+  }
+  const depthItems = entries.map((entry) => ({
+    depth: entry.level - 1,
+    ltype: null,
+    value: entry.text
+  }));
+  const trees = processDepths(null, depthItems);
+  const indexer = new TocIndexer;
+  return trees.map((tree) => buildTocList(indexer, tree.list));
+}
+
+// packages/parser/src/parser/rules/block/module/resolution/document.ts
+class ModuleDocumentRegistry {
+  footnotesByElement = new WeakMap;
+  diagnostics = [];
+  register(result, options = {}) {
+    const parseResult = isParseResult(result) ? result : null;
+    const ast = parseResult ? parseResult.ast : result;
+    const elements = options.stripLegacyImplicitFootnoteBlock ? stripTrailingDefaultFootnoteBlock(ast.elements) : ast.elements;
+    const registeredAst = elements === ast.elements ? ast : { ...ast, elements };
+    if (parseResult) {
+      this.diagnostics.push(...parseResult.diagnostics);
+    }
+    this.registerFootnotes(registeredAst);
+    return registeredAst;
+  }
+  finalize(ast, elements, pageTags, ensureFootnoteBlock = true) {
+    const normalizedElements = normalizeFootnoteBlocks(elements, ensureFootnoteBlock);
+    const footnotes = [];
+    const htmlBlocks = [];
+    const codeBlocks = [];
+    const tocEntries = [];
+    const collectElement = (element) => {
+      if (element.element === "footnote") {
+        const content = this.footnotesByElement.get(element);
+        if (content)
+          footnotes.push(content);
+      } else if (element.element === "html") {
+        htmlBlocks.push(element.data.contents);
+      } else if (element.element === "code") {
+        codeBlocks.push(element.data);
+      } else if (isTocHeading(element)) {
+        tocEntries.push({
+          level: element.data.type.header.level,
+          text: extractHeadingText(element.data.elements)
+        });
+      }
+    };
+    walkRenderOrder(normalizedElements, pageTags, collectElement);
+    const result = { ...ast, elements: normalizedElements };
+    setOptionalArray(result, "footnotes", footnotes);
+    setOptionalArray(result, "html-blocks", htmlBlocks);
+    setOptionalArray(result, "code-blocks", codeBlocks);
+    setOptionalArray(result, "table-of-contents", buildTableOfContents(tocEntries));
+    return result;
+  }
+  registerFootnotes(ast) {
+    const footnoteElements = [];
+    walkSyntaxOrder(ast.elements, (element) => {
+      if (element.element === "footnote")
+        footnoteElements.push(element);
+    });
+    for (let i = 0;i < footnoteElements.length; i++) {
+      const content = ast.footnotes?.[i];
+      if (content)
+        this.footnotesByElement.set(footnoteElements[i], content);
+    }
+  }
+}
+function isParseResult(result) {
+  return "ast" in result && "diagnostics" in result;
+}
+function setOptionalArray(tree, key, value) {
+  if (value.length > 0) {
+    tree[key] = value;
+  } else {
+    delete tree[key];
+  }
+}
+function stripTrailingDefaultFootnoteBlock(elements) {
+  const last = elements.at(-1);
+  if (last?.element !== "footnote-block" || last.data.title !== null || last.data.hide === true) {
+    return elements;
+  }
+  return elements.slice(0, -1);
+}
+function normalizeFootnoteBlocks(elements, ensureFootnoteBlock) {
+  const state = { found: false };
+  const normalized = mapSyntaxElements(elements, (element) => {
+    if (element.element !== "footnote-block")
+      return element;
+    if (state.found)
+      return null;
+    state.found = true;
+    return element;
+  });
+  if (!state.found && ensureFootnoteBlock) {
+    normalized.push({
+      element: "footnote-block",
+      data: { title: null, hide: false }
+    });
+  }
+  return normalized;
+}
+function containsSyntaxFootnoteBlock(elements) {
+  let found = false;
+  walkSyntaxOrder(elements, (element) => {
+    if (element.element === "footnote-block")
+      found = true;
+  });
+  return found;
 }
-function collectStylesFromElements(elements, styles, ctx) {
+function mapSyntaxElements(elements, transform) {
   const result = [];
+  for (const original of elements) {
+    const element = transform(original);
+    if (!element)
+      continue;
+    result.push(mapSyntaxChildren(element, (children) => mapSyntaxElements(children, transform)));
+  }
+  return result;
+}
+function mapSyntaxChildren(element, transform) {
+  if (element.element === "if") {
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        then: transform(element.data.then),
+        else: transform(element.data.else)
+      }
+    };
+  }
+  if (element.element === "ifexpr") {
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        then: transform(element.data.then),
+        else: transform(element.data.else)
+      }
+    };
+  }
+  if (element.element === "bibliography-block") {
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        entries: element.data.entries.map((entry) => ({
+          ...entry,
+          key: transform(entry.key),
+          value: transform(entry.value)
+        }))
+      }
+    };
+  }
+  if (element.element === "list") {
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        items: element.data.items.map((item) => item["item-type"] === "elements" ? { ...item, elements: transform(item.elements) } : mapSubList(item, transform))
+      }
+    };
+  }
+  if (element.element === "table") {
+    return {
+      ...element,
+      data: {
+        ...element.data,
+        rows: element.data.rows.map((row) => ({
+          ...row,
+          cells: row.cells.map((cell) => ({ ...cell, elements: transform(cell.elements) }))
+        }))
+      }
+    };
+  }
+  if (element.element === "definition-list") {
+    return {
+      ...element,
+      data: element.data.map((entry) => ({
+        ...entry,
+        key: transform(entry.key),
+        value: transform(entry.value)
+      }))
+    };
+  }
+  if (element.element === "tab-view") {
+    return {
+      ...element,
+      data: element.data.map((tab) => ({ ...tab, elements: transform(tab.elements) }))
+    };
+  }
+  const children = getGenericElementChildren(element);
+  return children === null ? element : withGenericElementChildren(element, transform(children));
+}
+function mapSubList(item, transform) {
+  const transformed = transform([listElement(item.data)])[0];
+  return transformed?.element === "list" ? { ...item, data: transformed.data } : item;
+}
+function walkSyntaxOrder(elements, callback) {
   for (const element of elements) {
-    if (element.element === "style") {
-      styles.push(element.data);
+    callback(element);
+    walkAllSyntaxChildren(element, (children) => walkSyntaxOrder(children, callback));
+  }
+}
+function walkRenderOrder(elements, pageTags, callback) {
+  for (const element of elements) {
+    callback(element);
+    if (element.element === "if") {
+      walkRenderOrder(import_ast3.isTruthy(element.data.condition) ? element.data.then : element.data.else, pageTags, callback);
+      continue;
+    }
+    if (element.element === "ifexpr") {
+      const evaluated = import_ast3.evaluateExpression(element.data.expression);
+      if (evaluated.success) {
+        walkRenderOrder(evaluated.value !== 0 ? element.data.then : element.data.else, pageTags, callback);
+      }
       continue;
     }
     if (element.element === "if-tags") {
-      const slotId = ctx.nextSlotId++;
-      styles.push(`${import_ast2.STYLE_SLOT_PREFIX}${slotId}`);
-      const data = { ...element.data, _styleSlot: slotId };
-      result.push({
-        element: "if-tags",
-        data
-      });
+      const resolved = resolveIfTags(element.data, pageTags);
+      if (!resolved.evaluated || resolved.matched) {
+        walkRenderOrder(element.data.elements, pageTags, callback);
+      }
+      continue;
+    }
+    if (element.element === "bibliography-block") {
+      if (!element.data.hide) {
+        for (const entry of element.data.entries) {
+          walkRenderOrder(entry.value, pageTags, callback);
+        }
+      }
       continue;
     }
-    result.push(mapElementChildren(element, (children) => collectStylesFromElements(children, styles, ctx)));
+    walkBasicChildren(element, (children) => walkRenderOrder(children, pageTags, callback));
   }
-  return result;
+}
+function walkAllSyntaxChildren(element, callback) {
+  if (element.element === "if" || element.element === "ifexpr") {
+    callback(element.data.then);
+    callback(element.data.else);
+    return;
+  }
+  if (element.element === "bibliography-block") {
+    for (const entry of element.data.entries) {
+      callback(entry.key);
+      callback(entry.value);
+    }
+    return;
+  }
+  walkBasicChildren(element, callback);
+}
+function walkBasicChildren(element, callback) {
+  if (element.element === "list") {
+    for (const item of element.data.items) {
+      callback(item["item-type"] === "elements" ? item.elements : [listElement(item.data)]);
+    }
+    return;
+  }
+  if (element.element === "table") {
+    for (const row of element.data.rows) {
+      for (const cell of row.cells)
+        callback(cell.elements);
+    }
+    return;
+  }
+  if (element.element === "definition-list") {
+    for (const entry of element.data) {
+      callback(entry.key);
+      callback(entry.value);
+    }
+    return;
+  }
+  if (element.element === "tab-view") {
+    for (const tab of element.data)
+      callback(tab.elements);
+    return;
+  }
+  const children = getGenericElementChildren(element);
+  if (children !== null)
+    callback(children);
+}
+function isTocHeading(element) {
+  return element.element === "container" && typeof element.data.type === "object" && "header" in element.data.type && element.data.type.header["has-toc"];
 }
 
 // packages/parser/src/parser/rules/block/module/resolve.ts
 var MODULE_SECONDARY_INCLUDE_MAX_ITERATIONS = 5;
 async function resolveModules(ast, dataProvider, options) {
-  const parse = createModuleParseFunction(options, dataProvider);
+  const registry = new ModuleDocumentRegistry;
+  registry.register(ast);
+  const parse = createModuleParseFunction(options, dataProvider, registry);
   const listPagesCtx = await buildListPagesContext(dataProvider, options.requirements.listPages ?? [], options.compiledListPagesTemplates, parse, options.urlPath);
   const listUsersCtx = await buildListUsersContext(dataProvider, options.requirements.listUsers ?? [], options.compiledListUsersTemplates, parse);
   const tagCloudCtx = await buildTagCloudContext(dataProvider, options.requirements.tagCloud ?? []);
   const pageTags = dataProvider.getPageTags?.() ?? null;
+  const resolvedStyleSlots = new Map;
+  const routedStyleAnchors = new WeakSet;
   const resolvedElements = walkAndResolve(ast.elements, {
     listPages: listPagesCtx,
     listUsers: listUsersCtx,
@@ -7218,24 +7691,30 @@ async function resolveModules(ast, dataProvider, options) {
     pageTags,
     listPagesIdCounter: 0,
     listUsersIdCounter: 0,
-    tagCloudIdCounter: 0
+    tagCloudIdCounter: 0,
+    resolvedStyleSlots,
+    routedStyleAnchors
   });
-  const { elements: finalElements, styles } = collectStyles(resolvedElements.elements);
+  const {
+    elements: finalElements,
+    styles,
+    anchoredStyles
+  } = collectStyles(resolvedElements.elements, routedStyleAnchors);
   const result = {
     ...ast,
     elements: finalElements
   };
-  if (styles.length > 0) {
-    result.styles = styles;
-  }
-  return result;
+  const mergedStyles = mergeCollectedStyles(ast.styles, styles, resolvedStyleSlots, anchoredStyles);
+  if (mergedStyles.length > 0)
+    result.styles = mergedStyles;
+  options.onDiagnostics?.(registry.diagnostics);
+  return registry.finalize(result, finalElements, pageTags, containsSyntaxFootnoteBlock(ast.elements));
 }
-function createModuleParseFunction(options, dataProvider) {
+function createModuleParseFunction(options, dataProvider, registry) {
   const transform = createModuleSourceTransform(options, dataProvider);
-  if (!transform) {
-    return options.parse;
-  }
-  return (source) => options.parse(transform(source));
+  return (source) => registry.register(options.parse(transform ? transform(source) : source), {
+    stripLegacyImplicitFootnoteBlock: true
+  });
 }
 function createModuleSourceTransform(options, dataProvider) {
   if (options.transformModuleSource) {
@@ -7250,7 +7729,7 @@ function createModuleSourceTransform(options, dataProvider) {
 }
 
 // packages/parser/src/parser/rules/block/module/index.ts
-var import_ast3 = require("@wdprlib/ast");
+var import_ast4 = require("@wdprlib/ast");
 
 // packages/parser/src/parser/rules/block/footnoteblock/attributes.ts
 function parseFootnoteBlockAttributes(ctx, startPos) {
@@ -12369,7 +12848,8 @@ function createParseContext(tokens, options = {}) {
     pos: 0,
     version: options.version ?? "wikidot",
     trackPositions: options.trackPositions ?? true,
-    settings: options.settings ?? import_ast4.DEFAULT_SETTINGS,
+    settings: options.settings ?? import_ast5.DEFAULT_SETTINGS,
+    appendImplicitFootnoteBlock: options.appendImplicitFootnoteBlock ?? true,
     footnotes: [],
     tocEntries: [],
     codeBlocks: [],
@@ -12887,67 +13367,6 @@ function suppressAtLevel(elements) {
 function suppressDivAdjacentParagraphs(elements) {
   return suppressAtLevel(elements);
 }
-// packages/parser/src/parser/toc.ts
-class TocIndexer {
-  index = 0;
-  next() {
-    return this.index++;
-  }
-}
-function buildTocList(indexer, items) {
-  const listItems = items.map((item) => buildTocListItem(indexer, item));
-  return {
-    element: "list",
-    data: {
-      type: "bullet",
-      attributes: {},
-      items: listItems
-    }
-  };
-}
-function buildTocListItem(indexer, item) {
-  if (item.kind === "list") {
-    return {
-      "item-type": "sub-list",
-      element: "list",
-      data: {
-        type: "bullet",
-        attributes: {},
-        items: item.children.map((child) => buildTocListItem(indexer, child))
-      }
-    };
-  }
-  const anchor = `#toc${indexer.next()}`;
-  const linkElement = {
-    element: "link",
-    data: {
-      type: "table-of-contents",
-      link: anchor,
-      extra: null,
-      label: { text: item.value },
-      target: null
-    }
-  };
-  return {
-    "item-type": "elements",
-    attributes: {},
-    elements: [linkElement]
-  };
-}
-function buildTableOfContents(entries) {
-  if (entries.length === 0) {
-    return [];
-  }
-  const depthItems = entries.map((entry) => ({
-    depth: entry.level - 1,
-    ltype: null,
-    value: entry.text
-  }));
-  const trees = processDepths(null, depthItems);
-  const indexer = new TocIndexer;
-  return trees.map((tree) => buildTocList(indexer, tree.list));
-}
-
 // packages/parser/src/parser/parse/footnotes.ts
 function containsFootnoteBlock(elements) {
   let found = false;
@@ -12961,7 +13380,9 @@ function containsFootnoteBlock(elements) {
 // packages/parser/src/parser/parse/result.ts
 function finalizeParseResult(ctx, children) {
   const cleanedChildren = postprocessChildren(children);
-  appendImplicitFootnoteBlock(cleanedChildren);
+  if (ctx.appendImplicitFootnoteBlock) {
+    appendImplicitFootnoteBlock(cleanedChildren);
+  }
   return {
     ast: buildSyntaxTree(ctx, cleanedChildren),
     diagnostics: ctx.diagnostics
@@ -13334,12 +13755,12 @@ function preprocess(text) {
 }
 
 // packages/parser/src/parser/preprocess/expr/evaluate.ts
-var import_ast5 = require("@wdprlib/ast");
+var import_ast6 = require("@wdprlib/ast");
 function evaluateDirective(kind, match) {
   if (kind === "expr") {
-    const result2 = import_ast5.evaluateExpression(match.head);
+    const result2 = import_ast6.evaluateExpression(match.head);
     if (result2.success)
-      return import_ast5.formatExprValue(result2.value);
+      return import_ast6.formatExprValue(result2.value);
     if (result2.error === "empty expression")
       return "";
     return "ERROR";
@@ -13347,11 +13768,11 @@ function evaluateDirective(kind, match) {
   if (kind === "if") {
     if (!match.hasPipe)
       return "";
-    return import_ast5.isTruthy(match.head) ? match.thenText : match.elseText;
+    return import_ast6.isTruthy(match.head) ? match.thenText : match.elseText;
   }
   if (!match.hasPipe)
     return "";
-  const result = import_ast5.evaluateExpression(match.head);
+  const result = import_ast6.evaluateExpression(match.head);
   if (!result.success)
     return "ERROR";
   return result.value !== 0 && !Number.isNaN(result.value) ? match.thenText : match.elseText;
@@ -13531,3 +13952,249 @@ function parse(source, options) {
   });
   return new Parser(tokens, options).parse();
 }
+// packages/parser/src/pipeline/process.ts
+var import_ast7 = require("@wdprlib/ast");
+
+// packages/parser/src/parser/rules/block/module/resolution/resolve-async.ts
+async function resolveModulesWithAsyncParse(ast, dataProvider, options) {
+  const registry = new ModuleDocumentRegistry;
+  registry.register(ast);
+  const parse2 = async (source) => registry.register(await options.parse(source));
+  const [listPagesData, listUsersData, tagCloudData] = await Promise.all([
+    buildListPagesDataMap(dataProvider, options.requirements.listPages ?? [], options.urlPath),
+    buildListUsersDataMap(dataProvider, options.requirements.listUsers ?? []),
+    buildTagCloudDataMap(dataProvider, options.requirements.tagCloud ?? [])
+  ]);
+  const context = {
+    dataProvider,
+    listPagesData,
+    listUsersData,
+    tagCloudData,
+    options,
+    parse: parse2
+  };
+  const state = { listPagesId: 0, listUsersId: 0, tagCloudId: 0 };
+  const resolvedElements = await resolveElements(ast.elements, context, state);
+  const { elements, styles, anchoredStyles } = collectStyles(resolvedElements);
+  const intermediate = { ...ast, elements };
+  const mergedStyles = mergeCollectedStyles(ast.styles, styles, new Map, anchoredStyles);
+  if (mergedStyles.length > 0)
+    intermediate.styles = mergedStyles;
+  else
+    delete intermediate.styles;
+  return {
+    ast: registry.finalize(intermediate, elements, options.pageTags),
+    diagnostics: registry.diagnostics
+  };
+}
+async function resolveElements(elements, context, state) {
+  const result = [];
+  for (const element of elements) {
+    if (element.element === "module") {
+      const resolved = await resolveModuleElement(element, context, state);
+      if (resolved !== null) {
+        result.push(...resolved);
+        continue;
+      }
+    }
+    if (element.element === "if-tags") {
+      const resolution = resolveIfTags(element.data, context.options.pageTags);
+      if (resolution.matched) {
+        result.push(...await resolveElements(element.data.elements, context, state));
+      }
+      continue;
+    }
+    result.push(await resolveElementChildren(element, context, state));
+  }
+  return result;
+}
+async function resolveModuleElement(element, context, state) {
+  if (isListPagesModule2(element.data)) {
+    const id = state.listPagesId++;
+    const data = context.listPagesData.get(id);
+    const template = context.options.compiledListPagesTemplates.get(id);
+    if (data && template)
+      return resolveListPagesAsync(element.data, data, template, context.parse);
+    return context.dataProvider.fetchListPages ? [] : [element];
+  }
+  if (isListUsersModule2(element.data)) {
+    const id = state.listUsersId++;
+    const data = context.listUsersData.get(id);
+    const template = context.options.compiledListUsersTemplates?.get(id);
+    if (data && template) {
+      const variableContext = { user: data.user };
+      return (await context.parse(template(variableContext))).elements;
+    }
+    return context.dataProvider.fetchListUsers ? [] : [element];
+  }
+  if (isTagCloudModule(element.data)) {
+    const id = state.tagCloudId++;
+    const data = context.tagCloudData.get(id);
+    if (data)
+      return resolveTagCloud(element.data, data);
+    return context.dataProvider.fetchTagCloud ? [] : [element];
+  }
+  return null;
+}
+async function resolveListPagesAsync(module2, data, template, parse2) {
+  if (data.pages.length === 0)
+    return [];
+  const result = [];
+  if (module2["prepend-line"] && !module2.separate) {
+    result.push(...(await parse2(module2["prepend-line"])).elements);
+  }
+  for (let i = 0;i < data.pages.length; i++) {
+    const page = data.pages[i];
+    if (!page)
+      continue;
+    const variableContext = {
+      page,
+      index: i + 1,
+      total: data.totalCount,
+      limit: module2.limit,
+      site: data.site
+    };
+    const parsed = await parse2(template(variableContext));
+    if (module2.separate) {
+      result.push({
+        element: "container",
+        data: {
+          type: "div",
+          attributes: { class: "list-pages-item" },
+          elements: parsed.elements
+        }
+      });
+    } else {
+      result.push(...parsed.elements);
+    }
+  }
+  if (module2["append-line"] && !module2.separate) {
+    result.push(...(await parse2(module2["append-line"])).elements);
+  }
+  return module2.wrapper ? [
+    {
+      element: "container",
+      data: {
+        type: "div",
+        attributes: { class: "list-pages-box" },
+        elements: result
+      }
+    }
+  ] : result;
+}
+async function resolveElementChildren(element, context, state) {
+  if (element.element === "list") {
+    const items = [];
+    for (const item of element.data.items) {
+      if (item["item-type"] === "elements") {
+        items.push({ ...item, elements: await resolveElements(item.elements, context, state) });
+      } else {
+        const resolved = (await resolveElements([listElement(item.data)], context, state))[0];
+        items.push(resolved?.element === "list" ? { ...item, data: resolved.data } : item);
+      }
+    }
+    return { ...element, data: { ...element.data, items } };
+  }
+  if (element.element === "table") {
+    const rows = [];
+    for (const row of element.data.rows) {
+      const cells = [];
+      for (const cell of row.cells) {
+        cells.push({ ...cell, elements: await resolveElements(cell.elements, context, state) });
+      }
+      rows.push({ ...row, cells });
+    }
+    return { ...element, data: { ...element.data, rows } };
+  }
+  if (element.element === "definition-list") {
+    const entries = [];
+    for (const entry of element.data) {
+      entries.push({
+        ...entry,
+        key: await resolveElements(entry.key, context, state),
+        value: await resolveElements(entry.value, context, state)
+      });
+    }
+    return { ...element, data: entries };
+  }
+  if (element.element === "tab-view") {
+    const tabs = [];
+    for (const tab of element.data) {
+      tabs.push({ ...tab, elements: await resolveElements(tab.elements, context, state) });
+    }
+    return { ...element, data: tabs };
+  }
+  const children = getGenericElementChildren(element);
+  return children === null ? element : withGenericElementChildren(element, await resolveElements(children, context, state));
+}
+
+// packages/parser/src/pipeline/process.ts
+async function processWikitext(source, options) {
+  const settings = options.settings ?? import_ast7.DEFAULT_SETTINGS;
+  const callbackContext = {
+    page: options.page,
+    settings
+  };
+  const dependencies = [];
+  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;
+  };
+  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), {
+      settings,
+      pageTags: options.page.tags,
+      appendImplicitFootnoteBlock: false
+    }),
+    compiledListPagesTemplates: extraction.compiledListPagesTemplates,
+    compiledListUsersTemplates: extraction.compiledListUsersTemplates,
+    requirements: extraction.requirements,
+    urlPath: options.page.urlPath,
+    pageTags: options.page.tags
+  });
+  return {
+    ast: resolved.ast,
+    page: options.page,
+    settings,
+    diagnostics: [...initial.diagnostics, ...resolved.diagnostics],
+    dependencies
+  };
+}
+function createModuleDataProvider(options, context) {
+  const provider = options.dataProvider;
+  return {
+    fetchListPages: provider?.fetchListPages ? (query, requirement) => provider.fetchListPages(query, requirement, context) : undefined,
+    fetchListUsers: provider?.fetchListUsers ? (requirement) => provider.fetchListUsers(requirement, context) : undefined,
+    fetchTagCloud: provider?.fetchTagCloud ? (requirement) => provider.fetchTagCloud(requirement, context) : undefined,
+    getPageTags: () => options.page.tags
+  };
+}
+function createRequestIncludeFetcher(fetcher) {
+  if (!fetcher)
+    return;
+  const cache = new Map;
+  return (pageRef) => {
+    const key = `${pageRef.site ?? ""}:${pageRef.page.toLowerCase()}`;
+    const cached = cache.get(key);
+    if (cached)
+      return cached;
+    const result = fetcher(pageRef).catch(() => null);
+    cache.set(key, result);
+    return result;
+  };
+}