@wdprlib/parser 2.1.0 → 3.0.0

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(exports_src, {
   resolveListUsers: () => resolveListUsers,
   resolveIncludesAsync: () => resolveIncludesAsync,
   resolveIncludes: () => resolveIncludes,
+  preprocessIftags: () => preprocessIftags,
   parseTags: () => parseTags,
   parseParent: () => parseParent,
   parseOrder: () => parseOrder,
@@ -83,6 +84,7 @@ class Lexer {
   state;
   options;
   splitBlockClosePositions = new Set;
+  blockOpenerDepth = 0;
   constructor(source, options = {}) {
     this.options = {
       trackPositions: options.trackPositions ?? true
@@ -182,6 +184,11 @@ class Lexer {
     const position = this.options.trackPositions ? import_ast.createPosition(startPos, endPos) : import_ast.createPosition(import_ast.createPoint(0, 0, 0), import_ast.createPoint(0, 0, 0));
     const lineStart = this.state.tokens.length === 0 || this.state.tokens[this.state.tokens.length - 1]?.type === "NEWLINE";
     this.state.tokens.push(createToken(type, value, position, lineStart));
+    if (type === "BLOCK_OPEN" || type === "BLOCK_END_OPEN") {
+      this.blockOpenerDepth++;
+    } else if (type === "BLOCK_CLOSE" && this.blockOpenerDepth > 0) {
+      this.blockOpenerDepth--;
+    }
   }
   scanToken() {
     const char = this.current();
@@ -446,7 +453,7 @@ class Lexer {
     }
     if (char === '"') {
       const lastNonWs = this.lastNonWhitespaceTokenType();
-      if (lastNonWs === "EQUALS") {
+      if (this.blockOpenerDepth > 0 && lastNonWs === "EQUALS") {
         let quoted = this.advance();
         while (!this.isAtEnd() && this.current() !== '"' && this.current() !== `
 `) {
@@ -646,6 +653,73 @@ var BLOCK_START_TOKENS = [
   "CLEAR_FLOAT_LEFT",
   "CLEAR_FLOAT_RIGHT"
 ];
+var KNOWN_BLOCK_NAMES = new Set([
+  "collapsible",
+  "div",
+  "div_",
+  "code",
+  "ul",
+  "ol",
+  "li",
+  "table",
+  "row",
+  "cell",
+  "hcell",
+  "tabview",
+  "tabs",
+  "module",
+  "module654",
+  "bibliography",
+  "footnoteblock",
+  "toc",
+  "iframe",
+  "math",
+  "html",
+  "iftags",
+  "include",
+  "f",
+  "embed",
+  "embedvideo",
+  "embedaudio",
+  "<",
+  ">",
+  "=",
+  "==",
+  "span",
+  "span_",
+  "user",
+  "a",
+  "anchor",
+  "size",
+  "footnote",
+  "eref",
+  "$",
+  "image",
+  "gallery",
+  "file"
+]);
+var INDENT_ACCEPTING_BLOCK_NAMES = new Set([
+  "bibliography",
+  "ul",
+  "ol",
+  "li",
+  "code",
+  "collapsible",
+  "div",
+  "div_",
+  "embed",
+  "embedvideo",
+  "embedaudio",
+  "html",
+  "iframe",
+  "iftags",
+  "math",
+  "module",
+  "module654",
+  "table",
+  "tabview",
+  "tabs"
+]);
 
 // packages/parser/src/parser/rules/utils.ts
 var SAFE_ATTRIBUTES = new Set([
@@ -772,13 +846,36 @@ function parseBlockName(ctx, startPos) {
 
 // packages/parser/src/parser/rules/inline/utils.ts
 function isExcludedBlockToken(ctx, tokenPos) {
-  if (!ctx.excludedBlockNames?.size)
+  const excluded = ctx.scope.excludedBlockNames;
+  if (!excluded?.size)
+    return false;
+  const token = ctx.tokens[tokenPos];
+  if (token?.type !== "BLOCK_OPEN" && token?.type !== "BLOCK_END_OPEN")
     return false;
+  const nameResult = parseBlockName(ctx, tokenPos + 1);
+  return nameResult !== null && excluded.has(nameResult.name);
+}
+function isUnknownBlockToken(ctx, tokenPos) {
+  const token = ctx.tokens[tokenPos];
+  if (token?.type !== "BLOCK_OPEN" && token?.type !== "BLOCK_END_OPEN")
+    return false;
+  const nameResult = parseBlockName(ctx, tokenPos + 1);
+  if (nameResult === null) {
+    if (ctx.tokens[tokenPos + 1]?.type === "EQUALS") {
+      return false;
+    }
+    return true;
+  }
+  return !KNOWN_BLOCK_NAMES.has(nameResult.name);
+}
+function isIndentAcceptingBlock(ctx, tokenPos) {
   const token = ctx.tokens[tokenPos];
   if (token?.type !== "BLOCK_OPEN" && token?.type !== "BLOCK_END_OPEN")
     return false;
   const nameResult = parseBlockName(ctx, tokenPos + 1);
-  return nameResult !== null && ctx.excludedBlockNames.has(nameResult.name);
+  if (nameResult === null)
+    return false;
+  return INDENT_ACCEPTING_BLOCK_NAMES.has(nameResult.name);
 }
 function canApplyInlineRule(rule, token) {
   if (rule.startTokens.length === 0) {
@@ -797,9 +894,9 @@ function parseInlineUntil(ctx, endType) {
     if (!token || token.type === "EOF") {
       break;
     }
-    if (paragraphMode && ctx.blockCloseCondition) {
+    if (paragraphMode && ctx.scope.blockCloseCondition) {
       const checkCtx = { ...ctx, pos };
-      if (ctx.blockCloseCondition(checkCtx)) {
+      if (ctx.scope.blockCloseCondition(checkCtx)) {
         break;
       }
     }
@@ -851,7 +948,7 @@ function parseInlineUntil(ctx, endType) {
           skipWhitespace++;
         }
         const blockNameToken = ctx.tokens[afterOpen + skipWhitespace];
-        if (blockNameToken && (blockNameToken.type === "TEXT" || blockNameToken.type === "IDENTIFIER") && blockNameToken.value.toLowerCase() === "footnoteblock" && ctx.footnoteBlockParsed) {
+        if (blockNameToken && (blockNameToken.type === "TEXT" || blockNameToken.type === "IDENTIFIER") && blockNameToken.value.toLowerCase() === "footnoteblock" && ctx.scope.footnoteBlockParsed) {
           isInvalidBlockOpen = true;
         }
       }
@@ -872,7 +969,9 @@ function parseInlineUntil(ctx, endType) {
         }
       }
       const isExcludedBlock = (nextMeaningfulToken?.type === "BLOCK_OPEN" || nextMeaningfulToken?.type === "BLOCK_END_OPEN") && isExcludedBlockToken(ctx, pos + lookAhead);
-      const isBlockStart = nextMeaningfulToken && BLOCK_START_TOKENS.includes(nextMeaningfulToken.type) && nextMeaningfulToken.lineStart && !isOrphanCloseSpan && !isAnchorName && !isInvalidBlockOpen && !isInvalidHeading && !isExcludedBlock;
+      const isUnknownBlock = (nextMeaningfulToken?.type === "BLOCK_OPEN" || nextMeaningfulToken?.type === "BLOCK_END_OPEN") && isUnknownBlockToken(ctx, pos + lookAhead);
+      const isIndentedBlockOpener = nextMeaningfulToken && (nextMeaningfulToken.type === "BLOCK_OPEN" || nextMeaningfulToken.type === "BLOCK_END_OPEN") && isIndentAcceptingBlock(ctx, pos + lookAhead);
+      const isBlockStart = nextMeaningfulToken && BLOCK_START_TOKENS.includes(nextMeaningfulToken.type) && (nextMeaningfulToken.lineStart || isIndentedBlockOpener) && !isOrphanCloseSpan && !isAnchorName && !isInvalidBlockOpen && !isInvalidHeading && !isExcludedBlock && !isUnknownBlock;
       if (!nextMeaningfulToken || nextMeaningfulToken.type === "NEWLINE" || nextMeaningfulToken.type === "EOF" || isBlockStart) {
         if (isBlockStart && nodes.length > 0) {
           const nextPos = pos + lookAhead;
@@ -1209,7 +1308,6 @@ function buildListData(topLtype, list) {
     items
   };
 }
-
 // packages/parser/src/parser/rules/block/utils.ts
 function canApplyBlockRule(rule, token) {
   if (rule.requiresLineStart && !token.lineStart) {
@@ -1251,8 +1349,11 @@ function parseBlocksUntil(ctx, closeCondition, options) {
       ...ctx,
       pos,
       blockRules,
-      blockCloseCondition: closeCondition,
-      excludedBlockNames: excluded
+      scope: {
+        ...ctx.scope,
+        blockCloseCondition: closeCondition,
+        excludedBlockNames: excluded
+      }
     };
     for (const rule of blockRules) {
       if (canApplyBlockRule(rule, token)) {
@@ -2240,15 +2341,15 @@ var divRule = {
     if (ctx.tokens[pos]?.type !== "NEWLINE") {
       return consumeFailedDiv(ctx);
     }
-    if (ctx.divClosesBudget === 0) {
+    if (ctx.scope.divClosesBudget === 0) {
       return { success: false };
     }
     pos++;
     consumed++;
     const openPosition = openToken.position;
     let bodyBudget;
-    if (ctx.divClosesBudget !== undefined) {
-      bodyBudget = ctx.divClosesBudget - 1;
+    if (ctx.scope.divClosesBudget !== undefined) {
+      bodyBudget = ctx.scope.divClosesBudget - 1;
     } else {
       const closesInScope = countDivCloses(ctx, pos);
       bodyBudget = closesInScope > 0 ? closesInScope - 1 : 0;
@@ -2263,7 +2364,11 @@ var divRule = {
       }
       return false;
     };
-    const bodyCtx = { ...ctx, pos, divClosesBudget: bodyBudget };
+    const bodyCtx = {
+      ...ctx,
+      pos,
+      scope: { ...ctx.scope, divClosesBudget: bodyBudget }
+    };
     let children;
     if (paragraphStrip) {
       const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
@@ -3906,10 +4011,10 @@ var footnoteBlockRule = {
     }
     pos++;
     consumed++;
-    if (ctx.footnoteBlockParsed) {
+    if (ctx.scope.footnoteBlockParsed) {
       return { success: false };
     }
-    ctx.footnoteBlockParsed = true;
+    ctx.scope = { ...ctx.scope, footnoteBlockParsed: true };
     const title = attrs.title !== undefined ? attrs.title : null;
     const hide = attrs.hide === "true" || attrs.hide === "yes";
     return {
@@ -4665,6 +4770,24 @@ var mathBlockRule = {
 };
 
 // packages/parser/src/parser/rules/block/html.ts
+function lookaheadHasHtmlClose(ctx, from) {
+  for (let i = from;i < ctx.tokens.length; i++) {
+    const t = ctx.tokens[i];
+    if (!t || t.type === "EOF")
+      return false;
+    if (t.type !== "BLOCK_END_OPEN")
+      continue;
+    const closeName = parseBlockName(ctx, i + 1);
+    if (closeName?.name.toLowerCase() !== "html")
+      continue;
+    let cp = i + 1 + closeName.consumed;
+    while (ctx.tokens[cp]?.type === "WHITESPACE")
+      cp++;
+    if (ctx.tokens[cp]?.type === "BLOCK_CLOSE")
+      return true;
+  }
+  return false;
+}
 var htmlBlockRule = {
   name: "html",
   startTokens: ["BLOCK_OPEN"],
@@ -4691,20 +4814,32 @@ var htmlBlockRule = {
     }
     pos++;
     consumed++;
+    const disabled = ctx.settings.allowHtmlBlocks === false;
+    const hasCloseAhead = disabled && lookaheadHasHtmlClose(ctx, pos);
     let contents = "";
     let foundClose = false;
     while (pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
       if (!token || token.type === "EOF")
         break;
+      if (disabled && !hasCloseAhead && token.type === "NEWLINE" && ctx.tokens[pos + 1]?.type === "NEWLINE") {
+        break;
+      }
       if (token.type === "BLOCK_END_OPEN") {
         const closeNameResult = parseBlockName(ctx, pos + 1);
         if (closeNameResult?.name.toLowerCase() === "html") {
-          foundClose = true;
-          break;
+          let checkPos = pos + 1 + closeNameResult.consumed;
+          while (ctx.tokens[checkPos]?.type === "WHITESPACE")
+            checkPos++;
+          if (ctx.tokens[checkPos]?.type === "BLOCK_CLOSE") {
+            foundClose = true;
+            break;
+          }
         }
       }
-      contents += token.value;
+      if (!disabled) {
+        contents += token.value;
+      }
       pos++;
       consumed++;
     }
@@ -4715,7 +4850,16 @@ var htmlBlockRule = {
         message: "Missing closing tag [[/html]] for [[html]]",
         position: openToken.position
       });
-      return { success: false };
+      if (!disabled) {
+        return { success: false };
+      }
+      ctx.diagnostics.push({
+        severity: "info",
+        code: "html-block-disabled",
+        message: "[[html]] block ignored: disabled by settings",
+        position: openToken.position
+      });
+      return { success: true, elements: [], consumed };
     }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
       pos++;
@@ -4725,6 +4869,10 @@ var htmlBlockRule = {
         pos += closeNameResult.consumed;
         consumed += closeNameResult.consumed;
       }
+      while (ctx.tokens[pos]?.type === "WHITESPACE") {
+        pos++;
+        consumed++;
+      }
       if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
         pos++;
         consumed++;
@@ -4734,6 +4882,15 @@ var htmlBlockRule = {
         consumed++;
       }
     }
+    if (disabled) {
+      ctx.diagnostics.push({
+        severity: "info",
+        code: "html-block-disabled",
+        message: "[[html]] block ignored: disabled by settings",
+        position: openToken.position
+      });
+      return { success: true, elements: [], consumed };
+    }
     contents = contents.trim();
     ctx.htmlBlocks.push(contents);
     return {
@@ -6419,6 +6576,82 @@ var commentRule = {
   }
 };
 
+// packages/parser/src/parser/rules/inline/html.ts
+var htmlInlineRule = {
+  name: "html",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+    let pos = ctx.pos + 1;
+    let consumed = 1;
+    const nameResult = parseBlockName(ctx, pos);
+    if (!nameResult || nameResult.name.toLowerCase() !== "html") {
+      return { success: false };
+    }
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
+    const attrResult = parseAttributesRaw(ctx, pos);
+    pos += attrResult.consumed;
+    consumed += attrResult.consumed;
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+    if (ctx.settings.allowHtmlBlocks !== false) {
+      return { success: false };
+    }
+    const hasCloseAhead = lookaheadHasHtmlClose(ctx, pos);
+    let foundClose = false;
+    while (pos < ctx.tokens.length) {
+      const token = ctx.tokens[pos];
+      if (!token || token.type === "EOF")
+        break;
+      if (!hasCloseAhead && token.type === "NEWLINE" && ctx.tokens[pos + 1]?.type === "NEWLINE") {
+        break;
+      }
+      if (token.type === "BLOCK_END_OPEN") {
+        const closeNameResult = parseBlockName(ctx, pos + 1);
+        if (closeNameResult?.name.toLowerCase() === "html") {
+          let checkPos = pos + 1 + closeNameResult.consumed;
+          while (ctx.tokens[checkPos]?.type === "WHITESPACE")
+            checkPos++;
+          if (ctx.tokens[checkPos]?.type === "BLOCK_CLOSE") {
+            foundClose = true;
+            consumed += checkPos - pos + 1;
+            pos = checkPos + 1;
+            if (ctx.tokens[pos]?.type === "NEWLINE") {
+              pos++;
+              consumed++;
+            }
+            break;
+          }
+        }
+      }
+      pos++;
+      consumed++;
+    }
+    if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/html]] for [[html]]",
+        position: openToken.position
+      });
+    }
+    ctx.diagnostics.push({
+      severity: "info",
+      code: "html-block-disabled",
+      message: "[[html]] block ignored: disabled by settings",
+      position: openToken.position
+    });
+    return { success: true, elements: [], consumed };
+  }
+};
+
 // packages/parser/src/parser/rules/inline/raw.ts
 var rawRule = {
   name: "raw",
@@ -8129,6 +8362,7 @@ var inlineRules = [
   underscoreLineBreakRule,
   newlineLineBreakRule,
   commentRule,
+  htmlInlineRule,
   rawRule,
   imageRule,
   sizeRule,
@@ -8646,89 +8880,339 @@ function buildTableOfContents(entries) {
   return trees.map((tree) => buildTocList(indexer, tree.list));
 }
 
-// packages/parser/src/parser/parse.ts
-class Parser {
-  ctx;
-  constructor(tokens, options = {}) {
-    this.ctx = {
-      tokens,
-      pos: 0,
-      version: options.version ?? "wikidot",
-      trackPositions: options.trackPositions ?? true,
-      settings: options.settings ?? import_ast2.DEFAULT_SETTINGS,
-      footnotes: [],
-      tocEntries: [],
-      codeBlocks: [],
-      htmlBlocks: [],
-      footnoteBlockParsed: false,
-      bibcites: [],
-      diagnostics: [],
-      blockRules,
-      blockFallbackRule: paragraphRule,
-      inlineRules
-    };
-  }
-  parse() {
-    const children = [];
-    while (!this.isAtEnd()) {
-      const blocks = this.parseBlock();
-      children.push(...blocks);
-    }
-    const mergedChildren = mergeSpanStripParagraphs(children);
-    const divProcessed = suppressDivAdjacentParagraphs(mergedChildren);
-    const cleanedChildren = cleanInternalFlags(divProcessed);
-    const hasFootnoteBlock = cleanedChildren.some((el) => el.element === "footnote-block");
-    if (!hasFootnoteBlock) {
-      cleanedChildren.push({
-        element: "footnote-block",
-        data: { title: null, hide: false }
-      });
+// packages/parser/src/parser/rules/block/module/walk.ts
+function walkElements(elements, callback) {
+  for (const element of elements) {
+    callback(element);
+    if (element.element === "list") {
+      const listData = element.data;
+      for (const item of listData.items) {
+        if (item["item-type"] === "elements") {
+          walkElements(item.elements, callback);
+        } else if (item["item-type"] === "sub-list") {
+          walkElements([{ element: "list", data: item.data }], callback);
+        }
+      }
+      continue;
     }
-    const tableOfContents = buildTableOfContents(this.ctx.tocEntries);
-    const result = {
-      elements: cleanedChildren
-    };
-    if (tableOfContents.length > 0) {
-      result["table-of-contents"] = tableOfContents;
+    if (element.element === "table") {
+      const tableData = element.data;
+      for (const row of tableData.rows) {
+        for (const cell of row.cells) {
+          walkElements(cell.elements, callback);
+        }
+      }
+      continue;
     }
-    if (this.ctx.footnotes.length > 0) {
-      result.footnotes = this.ctx.footnotes;
+    if (element.element === "definition-list") {
+      const defListData = element.data;
+      for (const item of defListData) {
+        walkElements(item.key, callback);
+        walkElements(item.value, callback);
+      }
+      continue;
     }
-    if (this.ctx.codeBlocks.length > 0) {
-      result["code-blocks"] = this.ctx.codeBlocks;
+    if (element.element === "tab-view") {
+      const tabData = element.data;
+      for (const tab of tabData) {
+        walkElements(tab.elements, callback);
+      }
+      continue;
     }
-    if (this.ctx.htmlBlocks.length > 0) {
-      result["html-blocks"] = this.ctx.htmlBlocks;
+    if ("data" in element && element.data && typeof element.data === "object") {
+      const data = element.data;
+      if ("elements" in data && Array.isArray(data.elements)) {
+        walkElements(data.elements, callback);
+      }
     }
-    return { ast: result, diagnostics: this.ctx.diagnostics };
-  }
-  isAtEnd() {
-    return this.ctx.pos >= this.ctx.tokens.length || this.currentToken().type === "EOF";
-  }
-  currentToken() {
-    return this.ctx.tokens[this.ctx.pos] ?? this.eofToken();
   }
-  eofToken() {
+}
+function mapElementChildren(element, transform) {
+  if (element.element === "list") {
+    const listData = element.data;
+    const newItems = [];
+    for (const item of listData.items) {
+      if (item["item-type"] === "elements") {
+        newItems.push({
+          "item-type": "elements",
+          attributes: item.attributes,
+          elements: transform(item.elements)
+        });
+      } else if (item["item-type"] === "sub-list") {
+        const subListResult = transform([{ element: "list", data: item.data }]);
+        const resolvedList = subListResult[0];
+        if (resolvedList?.element === "list") {
+          newItems.push({
+            "item-type": "sub-list",
+            element: "list",
+            data: resolvedList.data
+          });
+        } else {
+          newItems.push(item);
+        }
+      }
+    }
     return {
-      type: "EOF",
-      value: "",
-      position: {
-        start: { line: 0, column: 0, offset: 0 },
-        end: { line: 0, column: 0, offset: 0 }
-      },
-      lineStart: false
+      element: "list",
+      data: { ...listData, items: newItems }
     };
   }
-  skipWhitespace() {
-    while (this.currentToken().type === "WHITESPACE") {
-      this.ctx.pos++;
-    }
-  }
-  parseBlock() {
-    this.skipWhitespace();
-    if (this.isAtEnd()) {
-      return [];
-    }
+  if (element.element === "table") {
+    const tableData = element.data;
+    const newRows = [];
+    for (const row of tableData.rows) {
+      const newCells = [];
+      for (const cell of row.cells) {
+        newCells.push({ ...cell, elements: transform(cell.elements) });
+      }
+      newRows.push({ ...row, cells: newCells });
+    }
+    return {
+      element: "table",
+      data: { ...tableData, rows: newRows }
+    };
+  }
+  if (element.element === "definition-list") {
+    const defListData = element.data;
+    const newItems = [];
+    for (const item of defListData) {
+      newItems.push({
+        key_string: item.key_string,
+        key: transform(item.key),
+        value: transform(item.value)
+      });
+    }
+    return {
+      element: "definition-list",
+      data: newItems
+    };
+  }
+  if (element.element === "tab-view") {
+    const tabData = element.data;
+    const newTabs = [];
+    for (const tab of tabData) {
+      newTabs.push({ ...tab, elements: transform(tab.elements) });
+    }
+    return {
+      element: "tab-view",
+      data: newTabs
+    };
+  }
+  if ("data" in element && element.data && typeof element.data === "object") {
+    const data = element.data;
+    if ("elements" in data && Array.isArray(data.elements)) {
+      return {
+        ...element,
+        data: {
+          ...data,
+          elements: transform(data.elements)
+        }
+      };
+    }
+  }
+  return element;
+}
+function mapElementChildrenWithState(element, state, transform) {
+  if (element.element === "list") {
+    const listData = element.data;
+    const newItems = [];
+    let currentState = state;
+    for (const item of listData.items) {
+      if (item["item-type"] === "elements") {
+        const result = transform(item.elements, currentState);
+        newItems.push({
+          "item-type": "elements",
+          attributes: item.attributes,
+          elements: result.elements
+        });
+        currentState = result.state;
+      } else if (item["item-type"] === "sub-list") {
+        const result = transform([{ element: "list", data: item.data }], currentState);
+        const resolvedList = result.elements[0];
+        if (resolvedList?.element === "list") {
+          newItems.push({
+            "item-type": "sub-list",
+            element: "list",
+            data: resolvedList.data
+          });
+        } else {
+          newItems.push(item);
+        }
+        currentState = result.state;
+      }
+    }
+    return {
+      element: {
+        element: "list",
+        data: { ...listData, items: newItems }
+      },
+      state: currentState
+    };
+  }
+  if (element.element === "table") {
+    const tableData = element.data;
+    const newRows = [];
+    let currentState = state;
+    for (const row of tableData.rows) {
+      const newCells = [];
+      for (const cell of row.cells) {
+        const result = transform(cell.elements, currentState);
+        newCells.push({ ...cell, elements: result.elements });
+        currentState = result.state;
+      }
+      newRows.push({ ...row, cells: newCells });
+    }
+    return {
+      element: {
+        element: "table",
+        data: { ...tableData, rows: newRows }
+      },
+      state: currentState
+    };
+  }
+  if (element.element === "definition-list") {
+    const defListData = element.data;
+    const newItems = [];
+    let currentState = state;
+    for (const item of defListData) {
+      const keyResult = transform(item.key, currentState);
+      currentState = keyResult.state;
+      const valueResult = transform(item.value, currentState);
+      currentState = valueResult.state;
+      newItems.push({
+        key_string: item.key_string,
+        key: keyResult.elements,
+        value: valueResult.elements
+      });
+    }
+    return {
+      element: {
+        element: "definition-list",
+        data: newItems
+      },
+      state: currentState
+    };
+  }
+  if (element.element === "tab-view") {
+    const tabData = element.data;
+    const newTabs = [];
+    let currentState = state;
+    for (const tab of tabData) {
+      const result = transform(tab.elements, currentState);
+      newTabs.push({ ...tab, elements: result.elements });
+      currentState = result.state;
+    }
+    return {
+      element: {
+        element: "tab-view",
+        data: newTabs
+      },
+      state: currentState
+    };
+  }
+  if ("data" in element && element.data && typeof element.data === "object") {
+    const data = element.data;
+    if ("elements" in data && Array.isArray(data.elements)) {
+      const result = transform(data.elements, state);
+      return {
+        element: {
+          ...element,
+          data: {
+            ...data,
+            elements: result.elements
+          }
+        },
+        state: result.state
+      };
+    }
+  }
+  return { element, state };
+}
+
+// packages/parser/src/parser/parse.ts
+class Parser {
+  ctx;
+  constructor(tokens, options = {}) {
+    this.ctx = {
+      tokens,
+      pos: 0,
+      version: options.version ?? "wikidot",
+      trackPositions: options.trackPositions ?? true,
+      settings: options.settings ?? import_ast2.DEFAULT_SETTINGS,
+      footnotes: [],
+      tocEntries: [],
+      codeBlocks: [],
+      htmlBlocks: [],
+      bibcites: [],
+      diagnostics: [],
+      blockRules,
+      blockFallbackRule: paragraphRule,
+      inlineRules,
+      scope: {
+        footnoteBlockParsed: false
+      }
+    };
+  }
+  parse() {
+    const children = [];
+    while (!this.isAtEnd()) {
+      const blocks = this.parseBlock();
+      children.push(...blocks);
+    }
+    const mergedChildren = mergeSpanStripParagraphs(children);
+    const divProcessed = suppressDivAdjacentParagraphs(mergedChildren);
+    const cleanedChildren = cleanInternalFlags(divProcessed);
+    if (!containsFootnoteBlock(cleanedChildren)) {
+      cleanedChildren.push({
+        element: "footnote-block",
+        data: { title: null, hide: false }
+      });
+    }
+    const tableOfContents = buildTableOfContents(this.ctx.tocEntries);
+    const result = {
+      elements: cleanedChildren
+    };
+    if (tableOfContents.length > 0) {
+      result["table-of-contents"] = tableOfContents;
+    }
+    if (this.ctx.footnotes.length > 0) {
+      result.footnotes = this.ctx.footnotes;
+    }
+    if (this.ctx.codeBlocks.length > 0) {
+      result["code-blocks"] = this.ctx.codeBlocks;
+    }
+    if (this.ctx.htmlBlocks.length > 0) {
+      result["html-blocks"] = this.ctx.htmlBlocks;
+    }
+    return { ast: result, diagnostics: this.ctx.diagnostics };
+  }
+  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++;
+    }
+  }
+  parseBlock() {
+    this.skipWhitespace();
+    if (this.isAtEnd()) {
+      return [];
+    }
     const token = this.currentToken();
     if (token.type === "NEWLINE") {
       this.ctx.pos++;
@@ -8757,6 +9241,14 @@ function parse(source, options) {
   const tokens = tokenize(preprocessed, { trackPositions: options?.trackPositions });
   return new Parser(tokens, options).parse();
 }
+function containsFootnoteBlock(elements) {
+  let found = false;
+  walkElements(elements, (el) => {
+    if (el.element === "footnote-block")
+      found = true;
+  });
+  return found;
+}
 // packages/parser/src/parser/rules/block/module/listpages/compiler.ts
 var DEFAULT_PREVIEW_LENGTH = 200;
 var VARIABLE_REGEX = /%%([a-z_]+)(?:\{([^}]+)\})?(?:\((\d+)\))?(?:\|([^%]*(?:%(?!%)[^%]*)*))?%%/gi;
@@ -8964,348 +9456,99 @@ function strftime(date, format) {
         return String(date.getDate());
       case "H":
         return pad(date.getHours());
-      case "I":
-        return pad(date.getHours() % 12 || 12);
-      case "M":
-        return pad(date.getMinutes());
-      case "S":
-        return pad(date.getSeconds());
-      case "p":
-        return date.getHours() < 12 ? "AM" : "PM";
-      case "b":
-        return MONTHS_SHORT[date.getMonth()] ?? "";
-      case "B":
-        return MONTHS[date.getMonth()] ?? "";
-      case "a":
-        return DAYS_SHORT[date.getDay()] ?? "";
-      case "A":
-        return DAYS[date.getDay()] ?? "";
-      case "w":
-        return String(date.getDay());
-      case "j":
-        return pad(getDayOfYear(date), 3);
-      case "Z":
-        return "UTC";
-      case "z":
-        return "+0000";
-      case "%":
-        return "%";
-      default:
-        return `%${token}`;
-    }
-  });
-}
-function getDayOfYear(date) {
-  const start = new Date(date.getFullYear(), 0, 0);
-  const diff = date.getTime() - start.getTime();
-  const oneDay = 1000 * 60 * 60 * 24;
-  return Math.floor(diff / oneDay);
-}
-
-// packages/parser/src/parser/rules/block/module/listusers/compiler.ts
-var VARIABLE_REGEX2 = /%%([a-z_]+)%%/gi;
-function compileListUsersTemplate(template) {
-  const parts = [];
-  let lastIndex = 0;
-  for (const match of template.matchAll(VARIABLE_REGEX2)) {
-    if (match.index !== undefined && match.index > lastIndex) {
-      parts.push(template.slice(lastIndex, match.index));
-    }
-    const [, varName] = match;
-    if (!varName)
-      continue;
-    const getter = createVariableGetter2(varName.toLowerCase());
-    parts.push(getter);
-    lastIndex = match.index !== undefined ? match.index + match[0].length : lastIndex;
-  }
-  if (lastIndex < template.length) {
-    parts.push(template.slice(lastIndex));
-  }
-  return (ctx) => {
-    let result = "";
-    for (const part of parts) {
-      result += typeof part === "string" ? part : part(ctx);
-    }
-    return result;
-  };
-}
-function createVariableGetter2(name) {
-  switch (name) {
-    case "number":
-      return (ctx) => String(ctx.user.number);
-    case "title":
-      return (ctx) => ctx.user.title;
-    case "name":
-      return (ctx) => ctx.user.name;
-    default:
-      return () => "";
-  }
-}
-
-// packages/parser/src/parser/rules/block/module/listusers/extract.ts
-var VARIABLE_REGEX3 = /%%([a-z_]+)%%/gi;
-var KNOWN_VARIABLES = ["number", "title", "name"];
-function extractListUsersVariables(template) {
-  const variables = new Set;
-  for (const match of template.matchAll(VARIABLE_REGEX3)) {
-    const [, varName] = match;
-    if (!varName)
-      continue;
-    const normalized = varName.toLowerCase();
-    if (KNOWN_VARIABLES.includes(normalized)) {
-      variables.add(normalized);
-    }
-  }
-  return Array.from(variables);
-}
-
-// packages/parser/src/parser/rules/block/module/walk.ts
-function walkElements(elements, callback) {
-  for (const element of elements) {
-    callback(element);
-    if (element.element === "list") {
-      const listData = element.data;
-      for (const item of listData.items) {
-        if (item["item-type"] === "elements") {
-          walkElements(item.elements, callback);
-        } else if (item["item-type"] === "sub-list") {
-          walkElements([{ element: "list", data: item.data }], callback);
-        }
-      }
-      continue;
-    }
-    if (element.element === "table") {
-      const tableData = element.data;
-      for (const row of tableData.rows) {
-        for (const cell of row.cells) {
-          walkElements(cell.elements, callback);
-        }
-      }
-      continue;
-    }
-    if (element.element === "definition-list") {
-      const defListData = element.data;
-      for (const item of defListData) {
-        walkElements(item.key, callback);
-        walkElements(item.value, callback);
-      }
-      continue;
-    }
-    if (element.element === "tab-view") {
-      const tabData = element.data;
-      for (const tab of tabData) {
-        walkElements(tab.elements, callback);
-      }
-      continue;
-    }
-    if ("data" in element && element.data && typeof element.data === "object") {
-      const data = element.data;
-      if ("elements" in data && Array.isArray(data.elements)) {
-        walkElements(data.elements, callback);
-      }
-    }
-  }
-}
-function mapElementChildren(element, transform) {
-  if (element.element === "list") {
-    const listData = element.data;
-    const newItems = [];
-    for (const item of listData.items) {
-      if (item["item-type"] === "elements") {
-        newItems.push({
-          "item-type": "elements",
-          attributes: item.attributes,
-          elements: transform(item.elements)
-        });
-      } else if (item["item-type"] === "sub-list") {
-        const subListResult = transform([{ element: "list", data: item.data }]);
-        const resolvedList = subListResult[0];
-        if (resolvedList?.element === "list") {
-          newItems.push({
-            "item-type": "sub-list",
-            element: "list",
-            data: resolvedList.data
-          });
-        } else {
-          newItems.push(item);
-        }
-      }
-    }
-    return {
-      element: "list",
-      data: { ...listData, items: newItems }
-    };
-  }
-  if (element.element === "table") {
-    const tableData = element.data;
-    const newRows = [];
-    for (const row of tableData.rows) {
-      const newCells = [];
-      for (const cell of row.cells) {
-        newCells.push({ ...cell, elements: transform(cell.elements) });
-      }
-      newRows.push({ ...row, cells: newCells });
-    }
-    return {
-      element: "table",
-      data: { ...tableData, rows: newRows }
-    };
-  }
-  if (element.element === "definition-list") {
-    const defListData = element.data;
-    const newItems = [];
-    for (const item of defListData) {
-      newItems.push({
-        key_string: item.key_string,
-        key: transform(item.key),
-        value: transform(item.value)
-      });
-    }
-    return {
-      element: "definition-list",
-      data: newItems
-    };
-  }
-  if (element.element === "tab-view") {
-    const tabData = element.data;
-    const newTabs = [];
-    for (const tab of tabData) {
-      newTabs.push({ ...tab, elements: transform(tab.elements) });
-    }
-    return {
-      element: "tab-view",
-      data: newTabs
-    };
-  }
-  if ("data" in element && element.data && typeof element.data === "object") {
-    const data = element.data;
-    if ("elements" in data && Array.isArray(data.elements)) {
-      return {
-        ...element,
-        data: {
-          ...data,
-          elements: transform(data.elements)
-        }
-      };
+      case "I":
+        return pad(date.getHours() % 12 || 12);
+      case "M":
+        return pad(date.getMinutes());
+      case "S":
+        return pad(date.getSeconds());
+      case "p":
+        return date.getHours() < 12 ? "AM" : "PM";
+      case "b":
+        return MONTHS_SHORT[date.getMonth()] ?? "";
+      case "B":
+        return MONTHS[date.getMonth()] ?? "";
+      case "a":
+        return DAYS_SHORT[date.getDay()] ?? "";
+      case "A":
+        return DAYS[date.getDay()] ?? "";
+      case "w":
+        return String(date.getDay());
+      case "j":
+        return pad(getDayOfYear(date), 3);
+      case "Z":
+        return "UTC";
+      case "z":
+        return "+0000";
+      case "%":
+        return "%";
+      default:
+        return `%${token}`;
     }
-  }
-  return element;
+  });
 }
-function mapElementChildrenWithState(element, state, transform) {
-  if (element.element === "list") {
-    const listData = element.data;
-    const newItems = [];
-    let currentState = state;
-    for (const item of listData.items) {
-      if (item["item-type"] === "elements") {
-        const result = transform(item.elements, currentState);
-        newItems.push({
-          "item-type": "elements",
-          attributes: item.attributes,
-          elements: result.elements
-        });
-        currentState = result.state;
-      } else if (item["item-type"] === "sub-list") {
-        const result = transform([{ element: "list", data: item.data }], currentState);
-        const resolvedList = result.elements[0];
-        if (resolvedList?.element === "list") {
-          newItems.push({
-            "item-type": "sub-list",
-            element: "list",
-            data: resolvedList.data
-          });
-        } else {
-          newItems.push(item);
-        }
-        currentState = result.state;
-      }
-    }
-    return {
-      element: {
-        element: "list",
-        data: { ...listData, items: newItems }
-      },
-      state: currentState
-    };
-  }
-  if (element.element === "table") {
-    const tableData = element.data;
-    const newRows = [];
-    let currentState = state;
-    for (const row of tableData.rows) {
-      const newCells = [];
-      for (const cell of row.cells) {
-        const result = transform(cell.elements, currentState);
-        newCells.push({ ...cell, elements: result.elements });
-        currentState = result.state;
-      }
-      newRows.push({ ...row, cells: newCells });
+function getDayOfYear(date) {
+  const start = new Date(date.getFullYear(), 0, 0);
+  const diff = date.getTime() - start.getTime();
+  const oneDay = 1000 * 60 * 60 * 24;
+  return Math.floor(diff / oneDay);
+}
+
+// packages/parser/src/parser/rules/block/module/listusers/compiler.ts
+var VARIABLE_REGEX2 = /%%([a-z_]+)%%/gi;
+function compileListUsersTemplate(template) {
+  const parts = [];
+  let lastIndex = 0;
+  for (const match of template.matchAll(VARIABLE_REGEX2)) {
+    if (match.index !== undefined && match.index > lastIndex) {
+      parts.push(template.slice(lastIndex, match.index));
     }
-    return {
-      element: {
-        element: "table",
-        data: { ...tableData, rows: newRows }
-      },
-      state: currentState
-    };
+    const [, varName] = match;
+    if (!varName)
+      continue;
+    const getter = createVariableGetter2(varName.toLowerCase());
+    parts.push(getter);
+    lastIndex = match.index !== undefined ? match.index + match[0].length : lastIndex;
   }
-  if (element.element === "definition-list") {
-    const defListData = element.data;
-    const newItems = [];
-    let currentState = state;
-    for (const item of defListData) {
-      const keyResult = transform(item.key, currentState);
-      currentState = keyResult.state;
-      const valueResult = transform(item.value, currentState);
-      currentState = valueResult.state;
-      newItems.push({
-        key_string: item.key_string,
-        key: keyResult.elements,
-        value: valueResult.elements
-      });
-    }
-    return {
-      element: {
-        element: "definition-list",
-        data: newItems
-      },
-      state: currentState
-    };
+  if (lastIndex < template.length) {
+    parts.push(template.slice(lastIndex));
   }
-  if (element.element === "tab-view") {
-    const tabData = element.data;
-    const newTabs = [];
-    let currentState = state;
-    for (const tab of tabData) {
-      const result = transform(tab.elements, currentState);
-      newTabs.push({ ...tab, elements: result.elements });
-      currentState = result.state;
+  return (ctx) => {
+    let result = "";
+    for (const part of parts) {
+      result += typeof part === "string" ? part : part(ctx);
     }
-    return {
-      element: {
-        element: "tab-view",
-        data: newTabs
-      },
-      state: currentState
-    };
+    return result;
+  };
+}
+function createVariableGetter2(name) {
+  switch (name) {
+    case "number":
+      return (ctx) => String(ctx.user.number);
+    case "title":
+      return (ctx) => ctx.user.title;
+    case "name":
+      return (ctx) => ctx.user.name;
+    default:
+      return () => "";
   }
-  if ("data" in element && element.data && typeof element.data === "object") {
-    const data = element.data;
-    if ("elements" in data && Array.isArray(data.elements)) {
-      const result = transform(data.elements, state);
-      return {
-        element: {
-          ...element,
-          data: {
-            ...data,
-            elements: result.elements
-          }
-        },
-        state: result.state
-      };
+}
+
+// packages/parser/src/parser/rules/block/module/listusers/extract.ts
+var VARIABLE_REGEX3 = /%%([a-z_]+)%%/gi;
+var KNOWN_VARIABLES = ["number", "title", "name"];
+function extractListUsersVariables(template) {
+  const variables = new Set;
+  for (const match of template.matchAll(VARIABLE_REGEX3)) {
+    const [, varName] = match;
+    if (!varName)
+      continue;
+    const normalized = varName.toLowerCase();
+    if (KNOWN_VARIABLES.includes(normalized)) {
+      variables.add(normalized);
     }
   }
-  return { element, state };
+  return Array.from(variables);
 }
 
 // packages/parser/src/parser/rules/block/module/listpages/extract.ts
@@ -9964,6 +10207,110 @@ function resolveIfTags(data, pageTags) {
   const matched = evaluateTagCondition(condition, pageTags);
   return { evaluated: true, matched };
 }
+// packages/parser/src/parser/rules/block/module/iftags/preprocess.ts
+var BASE_PLACEHOLDER_OPEN = "";
+var BASE_PLACEHOLDER_CLOSE = "";
+var INNERMOST_IFTAGS_PATTERN = /\[\[\s*iftags\b([^\]]*)\]\]((?:(?!\[\[\s*iftags\b|\[\[\/\s*iftags\s*\]\]).)*)\[\[\/\s*iftags\s*\]\]/gis;
+var RAW_BLOCK_OPEN_PATTERN = /\[\[\s*(code|html)\b[^\]]*\]\]/iy;
+function preprocessIftags(source, pageTags) {
+  if (pageTags === null)
+    return source;
+  if (!source.includes("[["))
+    return source;
+  const sentinels = makeUniqueSentinels(source);
+  const { masked, placeholders } = maskRawRegions(source, sentinels);
+  const reduced = reduceIftags(masked, pageTags);
+  return restorePlaceholders(reduced, placeholders, sentinels);
+}
+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;
+  }
+  return { open, close };
+}
+function reduceIftags(source, pageTags) {
+  let current = source;
+  const maxIterations = source.length + 1;
+  for (let i = 0;i < maxIterations; i++) {
+    const next = current.replace(INNERMOST_IFTAGS_PATTERN, (_, cond, body) => {
+      const condition = parseTagCondition(cond);
+      return evaluateTagCondition(condition, pageTags) ? body : "";
+    });
+    if (next === current)
+      return current;
+    current = next;
+  }
+  return current;
+}
+function maskRawRegions(source, sentinels) {
+  const placeholders = [];
+  let masked = "";
+  let i = 0;
+  while (i < source.length) {
+    if (source[i] === "[" && source[i + 1] === "[") {
+      RAW_BLOCK_OPEN_PATTERN.lastIndex = i;
+      const openMatch = RAW_BLOCK_OPEN_PATTERN.exec(source);
+      if (openMatch) {
+        const name = openMatch[1].toLowerCase();
+        const openLen = openMatch[0].length;
+        const closePattern = new RegExp(`\\[\\[\\/\\s*${name}\\s*\\]\\]`, "ig");
+        closePattern.lastIndex = i + openLen;
+        const closeMatch = closePattern.exec(source);
+        if (closeMatch) {
+          const regionEnd = closeMatch.index + closeMatch[0].length;
+          masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
+          i = regionEnd;
+          continue;
+        }
+        if (name === "code") {
+          masked += pushPlaceholder(placeholders, source.slice(i), sentinels);
+          i = source.length;
+          continue;
+        }
+      }
+    }
+    if (source[i] === "@" && source[i + 1] === "<") {
+      const close = source.indexOf(">@", i + 2);
+      const newline = source.indexOf(`
+`, i + 2);
+      if (close !== -1 && (newline === -1 || close < newline)) {
+        const regionEnd = close + 2;
+        masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
+        i = regionEnd;
+        continue;
+      }
+    }
+    if (source[i] === "@" && source[i + 1] === "@") {
+      const close = source.indexOf("@@", i + 2);
+      const newline = source.indexOf(`
+`, i + 2);
+      if (close !== -1 && (newline === -1 || close < newline)) {
+        const regionEnd = close + 2;
+        masked += pushPlaceholder(placeholders, source.slice(i, regionEnd), sentinels);
+        i = regionEnd;
+        continue;
+      }
+    }
+    masked += source[i];
+    i++;
+  }
+  return { masked, placeholders };
+}
+function pushPlaceholder(placeholders, text, sentinels) {
+  const idx = placeholders.length;
+  placeholders.push(text);
+  return `${sentinels.open}${idx}${sentinels.close}`;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function restorePlaceholders(source, placeholders, sentinels) {
+  const pattern = new RegExp(`${escapeRegex(sentinels.open)}(\\d+)${escapeRegex(sentinels.close)}`, "g");
+  return source.replace(pattern, (_, idx) => placeholders[Number(idx)] ?? "");
+}
 // packages/parser/src/parser/rules/block/module/include/resolve.ts
 function resolveIncludes(source, fetcher, options) {
   if (options?.settings && !options.settings.enablePageSyntax) {
@@ -10009,7 +10356,67 @@ async function resolveIncludesAsync(source, fetcher, options) {
   };
   return expandIterativeAsync(source, cachedFetcher, maxIterations);
 }
-var INCLUDE_PATTERN = /^\[\[include\s([^\]]*(?:\](?!\])[^\]]*)*)\]\]/gim;
+var INCLUDE_OPEN_PATTERN = /^\[\[include\s/gim;
+function isRestOfLineBlank(source, pos) {
+  for (let i = pos;i < source.length; i++) {
+    const ch = source[i];
+    if (ch === `
+`)
+      return true;
+    if (ch !== " " && ch !== "\t" && ch !== "\r")
+      return false;
+  }
+  return true;
+}
+function scanIncludeDirectives(source) {
+  const matches = [];
+  const opener = new RegExp(INCLUDE_OPEN_PATTERN.source, INCLUDE_OPEN_PATTERN.flags);
+  let m;
+  while ((m = opener.exec(source)) !== null) {
+    const start = m.index;
+    const contentStart = start + m[0].length;
+    const firstNewline = source.indexOf(`
+`, start);
+    let depth = 0;
+    let linkDepth = 0;
+    let i = start;
+    let closeEnd = -1;
+    while (i < source.length) {
+      if (source.startsWith("[[[", i)) {
+        linkDepth++;
+        i += 3;
+      } else if (linkDepth > 0 && source.startsWith("]]]", i)) {
+        linkDepth--;
+        i += 3;
+      } else if (linkDepth > 0) {
+        i++;
+      } else if (source.startsWith("[[", i)) {
+        depth++;
+        i += 2;
+      } else if (source.startsWith("]]", i)) {
+        const closeStart = i;
+        depth--;
+        i += 2;
+        if (depth <= 0) {
+          const onOpenerLine = firstNewline === -1 || closeStart < firstNewline;
+          if (onOpenerLine || isRestOfLineBlank(source, i)) {
+            closeEnd = i;
+            break;
+          }
+        }
+      } else {
+        i++;
+      }
+    }
+    if (closeEnd === -1) {
+      opener.lastIndex = start + 2;
+      continue;
+    }
+    matches.push({ start, end: closeEnd, inner: source.slice(contentStart, closeEnd - 2) });
+    opener.lastIndex = closeEnd;
+  }
+  return matches;
+}
 function parseIncludeDirective(inner) {
   const normalized = inner.replace(/\n/g, " ");
   const parts = normalized.split("|");
@@ -10033,14 +10440,24 @@ function parseIncludeDirective(inner) {
     }
   }
   const variables = {};
+  const hasConcrete = new Set;
   for (const segment of varSegments) {
     const eqIndex = segment.indexOf("=");
-    if (eqIndex !== -1) {
-      const key = segment.slice(0, eqIndex).trim();
-      const value = segment.slice(eqIndex + 1).trim();
-      if (key) {
+    if (eqIndex === -1)
+      continue;
+    const key = segment.slice(0, eqIndex).trim();
+    if (!key)
+      continue;
+    const value = segment.slice(eqIndex + 1).trim();
+    const isPlaceholder = /^\{\$[^}]*\}$/.test(value);
+    const isConcrete = value !== "" && !isPlaceholder;
+    if (isConcrete) {
+      if (!hasConcrete.has(key)) {
         variables[key] = value;
+        hasConcrete.add(key);
       }
+    } else if (!Object.hasOwn(variables, key)) {
+      variables[key] = value;
     }
   }
   let location;
@@ -10057,7 +10474,7 @@ function parseIncludeDirective(inner) {
   }
   return { location, variables };
 }
-function replaceOneInclude(_match, inner, fetcher) {
+function replaceOneInclude(inner, fetcher) {
   const { location, variables } = parseIncludeDirective(inner);
   const content = fetcher(location);
   if (content === null) {
@@ -10070,25 +10487,33 @@ Page to be included "${location.page}" cannot be found!
 function expandIterative(source, fetcher, maxIterations) {
   let current = source;
   for (let i = 0;i < maxIterations; i++) {
-    const previous = current;
-    current = current.replace(INCLUDE_PATTERN, (_match, inner) => replaceOneInclude(_match, inner, fetcher));
-    if (current === previous)
+    const directives = scanIncludeDirectives(current);
+    if (directives.length === 0)
+      break;
+    let result = "";
+    let lastPos = 0;
+    for (const { start, end, inner } of directives) {
+      result += current.slice(lastPos, start);
+      result += replaceOneInclude(inner, fetcher);
+      lastPos = end;
+    }
+    result += current.slice(lastPos);
+    if (result === current)
       break;
+    current = result;
   }
   return current;
 }
 async function expandIterativeAsync(source, fetcher, maxIterations) {
   let current = source;
   for (let i = 0;i < maxIterations; i++) {
-    const previous = current;
-    const pattern = new RegExp(INCLUDE_PATTERN.source, INCLUDE_PATTERN.flags);
+    const directives = scanIncludeDirectives(current);
+    if (directives.length === 0)
+      break;
     let result = "";
     let lastPos = 0;
-    let match;
-    while ((match = pattern.exec(current)) !== null) {
-      const fullMatch = match[0];
-      const inner = match[1];
-      result += current.slice(lastPos, match.index);
+    for (const { start, end, inner } of directives) {
+      result += current.slice(lastPos, start);
       const { location, variables } = parseIncludeDirective(inner);
       const content = await fetcher(location);
       if (content === null) {
@@ -10098,12 +10523,12 @@ Page to be included "${location.page}" cannot be found!
       } else {
         result += substituteVariables(content, variables);
       }
-      lastPos = match.index + fullMatch.length;
+      lastPos = end;
     }
     result += current.slice(lastPos);
-    current = result;
-    if (current === previous)
+    if (result === current)
       break;
+    current = result;
   }
   return current;
 }