@wdprlib/parser 4.3.0 → 5.0.0

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   listItemElements,
   listItemSubList
 } from "@wdprlib/ast";
-import { createSettings, DEFAULT_SETTINGS as DEFAULT_SETTINGS2 } from "@wdprlib/ast";
+import { createSettings, DEFAULT_SETTINGS as DEFAULT_SETTINGS3 } from "@wdprlib/ast";
 
 // packages/parser/src/lexer/tokens.ts
 function createToken(type, value, position, lineStart = false) {
@@ -5782,6 +5782,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(module, data, compiledTemplate, parse) {
   const items = [];
@@ -5796,7 +5801,7 @@ function renderListPagesItems(module, data, compiledTemplate, parse) {
       limit: module.limit,
       site: data.site
     };
-    const itemAst = parse(compiledTemplate(ctx));
+    const itemAst = getModuleParseAst(parse(compiledTemplate(ctx)));
     if (module.separate) {
       items.push({
         element: "container",
@@ -5820,12 +5825,12 @@ function wrapListPagesResult(module, items, parse) {
   }
   const result = [];
   if (module["prepend-line"] && !module.separate) {
-    const prependAst = parse(module["prepend-line"]);
+    const prependAst = getModuleParseAst(parse(module["prepend-line"]));
     result.push(...prependAst.elements);
   }
   result.push(...items);
   if (module["append-line"] && !module.separate) {
-    const appendAst = parse(module["append-line"]);
+    const appendAst = getModuleParseAst(parse(module["append-line"]));
     result.push(...appendAst.elements);
   }
   if (module.wrapper) {
@@ -5851,6 +5856,60 @@ function resolveListPages(module, data, compiledTemplate, parse) {
   const items = renderListPagesItems(module, data, compiledTemplate, parse);
   return wrapListPagesResult(module, items, parse);
 }
+// packages/parser/src/parser/rules/block/module/listpages/types/external-data.ts
+function definePageData(input) {
+  const separator = input.fullname.indexOf(":");
+  const category = separator === -1 ? "_default" : input.fullname.slice(0, separator);
+  const name = separator === -1 ? input.fullname : input.fullname.slice(separator + 1);
+  return {
+    ...input,
+    name: input.name ?? name,
+    category: input.category ?? category,
+    hiddenTags: input.hiddenTags ?? [],
+    children: input.children ?? 0,
+    comments: input.comments ?? 0,
+    size: input.size ?? 0,
+    rating: input.rating ?? 0,
+    ratingVotes: input.ratingVotes ?? 0,
+    revisions: input.revisions ?? 0
+  };
+}
+// packages/parser/src/parser/rules/block/module/listpages/selectors.ts
+function matchesListPagesSelectors(page, query, currentPage) {
+  return matchesCategory(page.category, query.category, currentPage.category) && matchesTags(page, query.tags, currentPage);
+}
+function matchesCategory(category, selector, currentCategory) {
+  if (!selector)
+    return category === currentCategory;
+  if (selector.exclude.includes(category))
+    return false;
+  const hasPositiveSelector = selector.all || selector.current || selector.include.length > 0;
+  return !hasPositiveSelector || selector.all || selector.current && category === currentCategory || selector.include.includes(category);
+}
+function matchesTags(page, selector, currentPage) {
+  if (!selector)
+    return true;
+  const allTags = new Set([...page.tags, ...page.hiddenTags]);
+  if (selector.all.some((tag) => !allTags.has(tag)))
+    return false;
+  if (selector.any.length > 0 && !selector.any.some((tag) => allTags.has(tag)))
+    return false;
+  if (selector.none.some((tag) => allTags.has(tag)))
+    return false;
+  if (selector.special === "none")
+    return allTags.size === 0;
+  const currentTags = new Set(currentPage.tags.filter((tag) => !tag.startsWith("_")));
+  if (selector.special === "same-visible") {
+    return page.tags.some((tag) => currentTags.has(tag));
+  }
+  if (selector.special === "same-all") {
+    return setsEqual(new Set(page.tags), currentTags);
+  }
+  return true;
+}
+function setsEqual(left, right) {
+  return left.size === right.size && [...left].every((value) => right.has(value));
+}
 // packages/parser/src/parser/rules/block/module/listpages/url-resolution/fields.ts
 var URL_RESOLVABLE_FIELDS = [
   { attr: "offset", queryKey: "offset", type: "number" },
@@ -6280,13 +6339,20 @@ var BASE_PLACEHOLDER_OPEN = "";
 var BASE_PLACEHOLDER_CLOSE = "";
 var RAW_BLOCK_OPEN_PATTERN = /\[\[\s*(code|html)\b[^\]]*\]\]/iy;
 function makeUniqueSentinels(source) {
-  let open = BASE_PLACEHOLDER_OPEN;
-  let close = BASE_PLACEHOLDER_CLOSE;
-  while (source.includes(open) || source.includes(close)) {
-    open += BASE_PLACEHOLDER_OPEN;
-    close += BASE_PLACEHOLDER_CLOSE;
+  let openRun = 0;
+  let closeRun = 0;
+  let longestOpenRun = 0;
+  let longestCloseRun = 0;
+  for (const char of source) {
+    openRun = char === BASE_PLACEHOLDER_OPEN ? openRun + 1 : 0;
+    closeRun = char === BASE_PLACEHOLDER_CLOSE ? closeRun + 1 : 0;
+    longestOpenRun = Math.max(longestOpenRun, openRun);
+    longestCloseRun = Math.max(longestCloseRun, closeRun);
   }
-  return { open, close };
+  return {
+    open: BASE_PLACEHOLDER_OPEN.repeat(longestOpenRun + 1),
+    close: BASE_PLACEHOLDER_CLOSE.repeat(longestCloseRun + 1)
+  };
 }
 function maskRawRegions(source, sentinels) {
   const placeholders = [];
@@ -6744,16 +6810,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))
@@ -6791,12 +6872,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;
@@ -6806,7 +6888,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);
@@ -6848,12 +6934,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 ?? "";
@@ -6867,7 +6961,7 @@ function isListUsersModule2(module) {
 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
@@ -7020,6 +7114,117 @@ function countDynamicModules(elements) {
   return counts;
 }
 
+// packages/parser/src/parser/rules/block/module/resolution/styles.ts
+import { STYLE_ANCHOR_PREFIX, STYLE_SLOT_PREFIX } from "@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(STYLE_SLOT_PREFIX);
+}
+function createStyleSlotMarker(slotId) {
+  return `${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(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(STYLE_SLOT_PREFIX)) {
+        styles.push(css);
+        continue;
+      }
+      if (css.startsWith(STYLE_ANCHOR_PREFIX)) {
+        anchors.push(element);
+        if (ignoredAnchors.has(element)) {
+          result.push(element);
+          continue;
+        }
+        const anchoredCss = css.slice(STYLE_ANCHOR_PREFIX.length);
+        styles.push(anchoredCss);
+        anchoredStyles.push(anchoredCss);
+        result.push(element);
+        continue;
+      }
+      styles.push(css);
+      const anchor = { element: "style", data: `${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 = [];
@@ -7042,6 +7247,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, {
@@ -7050,11 +7256,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;
@@ -7109,44 +7327,361 @@ function walkAndResolve(elements, ctx) {
   };
 }
 
-// packages/parser/src/parser/rules/block/module/resolution/styles.ts
-import { STYLE_SLOT_PREFIX } from "@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
+import {
+  evaluateExpression,
+  isTruthy
+} from "@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(isTruthy(element.data.condition) ? element.data.then : element.data.else, pageTags, callback);
+      continue;
+    }
+    if (element.element === "ifexpr") {
+      const evaluated = 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(`${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,
@@ -7157,24 +7692,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) {
@@ -12309,6 +12850,7 @@ function createParseContext(tokens, options = {}) {
     version: options.version ?? "wikidot",
     trackPositions: options.trackPositions ?? true,
     settings: options.settings ?? DEFAULT_SETTINGS,
+    appendImplicitFootnoteBlock: options.appendImplicitFootnoteBlock ?? true,
     footnotes: [],
     tocEntries: [],
     codeBlocks: [],
@@ -12826,67 +13368,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;
@@ -12900,7 +13381,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
@@ -13272,30 +13755,6 @@ function preprocess(text) {
   return result;
 }
 
-// packages/parser/src/parser/preprocess/expr/evaluate.ts
-import { evaluateExpression, formatExprValue, isTruthy } from "@wdprlib/ast";
-function evaluateDirective(kind, match) {
-  if (kind === "expr") {
-    const result2 = evaluateExpression(match.head);
-    if (result2.success)
-      return formatExprValue(result2.value);
-    if (result2.error === "empty expression")
-      return "";
-    return "ERROR";
-  }
-  if (kind === "if") {
-    if (!match.hasPipe)
-      return "";
-    return isTruthy(match.head) ? match.thenText : match.elseText;
-  }
-  if (!match.hasPipe)
-    return "";
-  const result = evaluateExpression(match.head);
-  if (!result.success)
-    return "ERROR";
-  return result.value !== 0 && !Number.isNaN(result.value) ? match.thenText : match.elseText;
-}
-
 // packages/parser/src/parser/preprocess/expr/chars.ts
 function isWhitespace(ch) {
   return ch === " " || ch === "\t" || ch === `
@@ -13324,6 +13783,30 @@ function matchDirectiveKind(source, i) {
   return null;
 }
 
+// packages/parser/src/parser/preprocess/expr/evaluate.ts
+import { evaluateExpression as evaluateExpression2, formatExprValue, isTruthy as isTruthy2 } from "@wdprlib/ast";
+function evaluateDirective(kind, match) {
+  if (kind === "expr") {
+    const result2 = evaluateExpression2(match.head);
+    if (result2.success)
+      return formatExprValue(result2.value);
+    if (result2.error === "empty expression")
+      return "";
+    return "ERROR";
+  }
+  if (kind === "if") {
+    if (!match.hasPipe)
+      return "";
+    return isTruthy2(match.head) ? match.thenText : match.elseText;
+  }
+  if (!match.hasPipe)
+    return "";
+  const result = evaluateExpression2(match.head);
+  if (!result.success)
+    return "ERROR";
+  return result.value !== 0 && !Number.isNaN(result.value) ? match.thenText : match.elseText;
+}
+
 // packages/parser/src/parser/preprocess/expr/parse.ts
 function tryParseInnermostDirective(source, start, kind) {
   const keywordLen = kind === "ifexpr" ? 6 : kind === "expr" ? 4 : 2;
@@ -13425,11 +13908,14 @@ function expandInnermost(source) {
 }
 
 // packages/parser/src/parser/preprocess/expr/index.ts
+var MAX_EXPR_NESTING = 64;
 function preprocessExpr(source) {
   if (!source.includes("[[#"))
     return source;
   const sentinels = makeUniqueSentinels(source);
   const { masked, placeholders } = maskRawRegions(source, sentinels);
+  if (exceedsExprNestingLimit(masked))
+    return source;
   const reduced = reduceExpr(masked);
   return restorePlaceholders(reduced, placeholders, sentinels);
 }
@@ -13444,6 +13930,26 @@ function reduceExpr(source) {
   }
   return current2;
 }
+function exceedsExprNestingLimit(source) {
+  const expressionStack = [];
+  let expressionDepth = 0;
+  for (let i = 0;i < source.length; i++) {
+    if (source.startsWith("[[", i)) {
+      const isExpression = matchDirectiveKind(source, i) !== null;
+      expressionStack.push(isExpression);
+      if (isExpression && ++expressionDepth > MAX_EXPR_NESTING)
+        return true;
+      i++;
+      continue;
+    }
+    if (source.startsWith("]]", i)) {
+      if (expressionStack.pop())
+        expressionDepth--;
+      i++;
+    }
+  }
+  return false;
+}
 
 // packages/parser/src/parser/parse/source.ts
 function prepareSourceForParse(source, options) {
@@ -13470,6 +13976,287 @@ function parse(source, options) {
   });
   return new Parser(tokens, options).parse();
 }
+// packages/parser/src/pipeline/process.ts
+import {
+  DEFAULT_SETTINGS as DEFAULT_SETTINGS2
+} from "@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(module, data, template, parse2) {
+  if (data.pages.length === 0)
+    return [];
+  const result = [];
+  if (module["prepend-line"] && !module.separate) {
+    result.push(...(await parse2(module["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: module.limit,
+      site: data.site
+    };
+    const parsed = await parse2(template(variableContext));
+    if (module.separate) {
+      result.push({
+        element: "container",
+        data: {
+          type: "div",
+          attributes: { class: "list-pages-item" },
+          elements: parsed.elements
+        }
+      });
+    } else {
+      result.push(...parsed.elements);
+    }
+  }
+  if (module["append-line"] && !module.separate) {
+    result.push(...(await parse2(module["append-line"])).elements);
+  }
+  return module.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
+var DEFAULT_MODULE_MAX_PASSES = 5;
+var PIPELINE_DIAGNOSTIC_POSITION = {
+  start: { line: 1, column: 1, offset: 0 },
+  end: { line: 1, column: 1, offset: 0 }
+};
+async function processWikitext(source, options) {
+  const settings = options.settings ?? DEFAULT_SETTINGS2;
+  const callbackContext = {
+    page: options.page,
+    settings
+  };
+  const dependencies = [];
+  const diagnostics = [];
+  const fetchInclude = createRequestIncludeFetcher(options.dataProvider?.fetchInclude ? (pageRef) => options.dataProvider.fetchInclude(pageRef, callbackContext) : undefined);
+  const resolveSource = async (input) => {
+    if (!fetchInclude)
+      return input;
+    const resolution = await resolveIncludesAsyncWithTrace(input, fetchInclude, {
+      maxIterations: options.includeMaxIterations,
+      settings
+    });
+    dependencies.push(...resolution.dependencies);
+    if (resolution.reachedMaxIterations) {
+      diagnostics.push(createLimitDiagnostic("include-resolution-limit", `Include expansion stopped after ${options.includeMaxIterations ?? 10} iterations.`));
+    }
+    return resolution.source;
+  };
+  const expandedSource = await resolveSource(source);
+  const initial = parse(expandedSource, {
+    settings,
+    pageTags: options.page.tags,
+    appendImplicitFootnoteBlock: false
+  });
+  diagnostics.push(...initial.diagnostics);
+  const dataProvider = createModuleDataProvider(options, callbackContext);
+  const parseFragment = async (fragmentSource) => parse(await resolveSource(fragmentSource), {
+    settings,
+    pageTags: options.page.tags,
+    appendImplicitFootnoteBlock: false
+  });
+  let ast = initial.ast;
+  for (let pass = 0;pass < DEFAULT_MODULE_MAX_PASSES; pass++) {
+    const extraction = extractDataRequirements(ast);
+    if (pass > 0 && !hasResolvableRequirements(extraction.requirements, options.dataProvider)) {
+      break;
+    }
+    const resolved = await resolveModulesWithAsyncParse(ast, dataProvider, {
+      parse: parseFragment,
+      compiledListPagesTemplates: extraction.compiledListPagesTemplates,
+      compiledListUsersTemplates: extraction.compiledListUsersTemplates,
+      requirements: extraction.requirements,
+      urlPath: options.page.urlPath,
+      pageTags: options.page.tags
+    });
+    ast = resolved.ast;
+    diagnostics.push(...resolved.diagnostics);
+  }
+  if (hasResolvableRequirements(extractDataRequirements(ast).requirements, options.dataProvider)) {
+    diagnostics.push(createLimitDiagnostic("module-resolution-limit", `Module resolution stopped after ${DEFAULT_MODULE_MAX_PASSES} passes.`));
+  }
+  return {
+    ast,
+    page: options.page,
+    settings,
+    diagnostics,
+    dependencies
+  };
+}
+function hasResolvableRequirements(requirements, provider) {
+  return Boolean(provider?.fetchListPages && requirements.listPages.length > 0 || provider?.fetchListUsers && requirements.listUsers.length > 0 || provider?.fetchTagCloud && requirements.tagCloud.length > 0);
+}
+function createLimitDiagnostic(code, message) {
+  return {
+    severity: "warning",
+    code,
+    message,
+    position: PIPELINE_DIAGNOSTIC_POSITION
+  };
+}
+function createModuleDataProvider(options, context) {
+  const provider = options.dataProvider;
+  return {
+    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;
+  };
+}
 export {
   tokenize,
   text,
@@ -13477,8 +14264,10 @@ export {
   resolveModules,
   resolveListUsers,
   resolveIncludesWithTrace,
+  resolveIncludesAsyncWithTrace,
   resolveIncludesAsync,
   resolveIncludes,
+  processWikitext,
   preprocessIftags,
   parseTags,
   parseParent,
@@ -13489,6 +14278,7 @@ export {
   parse,
   paragraph,
   normalizeQuery,
+  matchesListPagesSelectors,
   listItemSubList,
   listItemElements,
   list,
@@ -13502,6 +14292,7 @@ export {
   extractListUsersVariables,
   extractIncludeReferences,
   extractDataRequirements,
+  definePageData,
   createToken,
   createSettings,
   createPosition,
@@ -13513,5 +14304,5 @@ export {
   STYLE_SLOT_PREFIX2 as STYLE_SLOT_PREFIX,
   Parser,
   Lexer,
-  DEFAULT_SETTINGS2 as DEFAULT_SETTINGS
+  DEFAULT_SETTINGS3 as DEFAULT_SETTINGS
 };