@wdprlib/parser 1.1.2 → 2.0.0

package/dist/index.cjs

@@ -31,7 +31,7 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   tokenize: () => tokenize,
-  text: () => import_ast3.text,
+  text: () => import_ast5.text,
   resolveModules: () => resolveModules,
   resolveListUsers: () => resolveListUsers,
   resolveIncludes: () => resolveIncludes,
@@ -42,34 +42,35 @@ __export(exports_src, {
   parseDateSelector: () => parseDateSelector,
   parseCategory: () => parseCategory,
   parse: () => parse,
-  paragraph: () => import_ast3.paragraph,
+  paragraph: () => import_ast5.paragraph,
   normalizeQuery: () => normalizeQuery,
-  listItemSubList: () => import_ast3.listItemSubList,
-  listItemElements: () => import_ast3.listItemElements,
-  list: () => import_ast3.list,
-  link: () => import_ast3.link,
-  lineBreak: () => import_ast3.lineBreak,
-  italics: () => import_ast3.italics,
+  listItemSubList: () => import_ast5.listItemSubList,
+  listItemElements: () => import_ast5.listItemElements,
+  list: () => import_ast5.list,
+  link: () => import_ast5.link,
+  lineBreak: () => import_ast5.lineBreak,
+  italics: () => import_ast5.italics,
   isListUsersModule: () => isListUsersModule2,
-  horizontalRule: () => import_ast3.horizontalRule,
-  heading: () => import_ast3.heading,
+  horizontalRule: () => import_ast5.horizontalRule,
+  heading: () => import_ast5.heading,
   extractListUsersVariables: () => extractListUsersVariables,
   extractDataRequirements: () => extractDataRequirements,
   createToken: () => createToken,
-  createSettings: () => import_ast4.createSettings,
-  createPosition: () => import_ast3.createPosition,
-  createPoint: () => import_ast3.createPoint,
-  container: () => import_ast3.container,
+  createSettings: () => import_ast6.createSettings,
+  createPosition: () => import_ast5.createPosition,
+  createPoint: () => import_ast5.createPoint,
+  container: () => import_ast5.container,
   compileTemplate: () => compileTemplate,
   compileListUsersTemplate: () => compileListUsersTemplate,
-  bold: () => import_ast3.bold,
+  bold: () => import_ast5.bold,
+  STYLE_SLOT_PREFIX: () => import_ast4.STYLE_SLOT_PREFIX,
   Parser: () => Parser,
   Lexer: () => Lexer,
-  DEFAULT_SETTINGS: () => import_ast4.DEFAULT_SETTINGS
+  DEFAULT_SETTINGS: () => import_ast6.DEFAULT_SETTINGS
 });
 module.exports = __toCommonJS(exports_src);
-var import_ast3 = require("@wdprlib/ast");
-var import_ast4 = require("@wdprlib/ast");
+var import_ast5 = require("@wdprlib/ast");
+var import_ast6 = require("@wdprlib/ast");
 
 // packages/parser/src/lexer/tokens.ts
 function createToken(type, value, position, lineStart = false) {
@@ -1527,6 +1528,17 @@ function parseLiItem(ctx, startPos, listType) {
       pos++;
     }
   }
+  if (!isLiClose(ctx, pos)) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: "Missing closing tag [[/li]] for [[li]]",
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 }
+      }
+    });
+  }
   if (isLiClose(ctx, pos)) {
     const closeConsumed = consumeCloseTag(ctx, pos);
     consumed += closeConsumed;
@@ -1619,11 +1631,13 @@ function parseListBlock(ctx, startPos, listType) {
     consumed++;
   }
   const items = [];
+  let foundListClose = false;
   while (pos < ctx.tokens.length) {
     const token = ctx.tokens[pos];
     if (!token || token.type === "EOF")
       break;
     if (isListClose(ctx, pos, listType)) {
+      foundListClose = true;
       const closeConsumed = consumeCloseTag(ctx, pos);
       consumed += closeConsumed;
       break;
@@ -1747,6 +1761,17 @@ function parseListBlock(ctx, startPos, listType) {
       });
     }
   }
+  if (!foundListClose) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: `Missing closing tag [[/${listType}]] for [[${listType}]]`,
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 }
+      }
+    });
+  }
   const listData = {
     type: listType === "ol" ? "numbered" : "bullet",
     attributes: attrResult.attrs,
@@ -2182,8 +2207,19 @@ var divRule = {
     if (ctx.tokens[pos]?.type !== "NEWLINE") {
       return consumeFailedDiv(ctx);
     }
+    if (ctx.divClosesBudget === 0) {
+      return { success: false };
+    }
     pos++;
     consumed++;
+    const openPosition = openToken.position;
+    let bodyBudget;
+    if (ctx.divClosesBudget !== undefined) {
+      bodyBudget = ctx.divClosesBudget - 1;
+    } else {
+      const closesInScope = countDivCloses(ctx, pos);
+      bodyBudget = closesInScope > 0 ? closesInScope - 1 : 0;
+    }
     const closeCondition = (checkCtx) => {
       const token = checkCtx.tokens[checkCtx.pos];
       if (token?.type === "BLOCK_END_OPEN") {
@@ -2194,7 +2230,7 @@ var divRule = {
       }
       return false;
     };
-    const bodyCtx = { ...ctx, pos };
+    const bodyCtx = { ...ctx, pos, divClosesBudget: bodyBudget };
     let children;
     if (paragraphStrip) {
       const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
@@ -2207,6 +2243,14 @@ var divRule = {
       pos += bodyResult.consumed;
       children = bodyResult.elements;
     }
+    if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/div]] for [[${blockName}]]`,
+        position: openPosition
+      });
+    }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
       pos++;
       consumed++;
@@ -2240,6 +2284,21 @@ var divRule = {
     };
   }
 };
+function countDivCloses(ctx, startPos) {
+  let count = 0;
+  for (let i = startPos;i < ctx.tokens.length; i++) {
+    const t = ctx.tokens[i];
+    if (!t || t.type === "EOF")
+      break;
+    if (t.type === "BLOCK_END_OPEN") {
+      const nameResult = parseBlockName(ctx, i + 1);
+      if (nameResult?.name === "div") {
+        count++;
+      }
+    }
+  }
+  return count;
+}
 function consumeFailedDiv(ctx) {
   const elements = [];
   let pos = ctx.pos;
@@ -2251,6 +2310,20 @@ function consumeFailedDiv(ctx) {
     const t = ctx.tokens[scanPos];
     if (!t || t.type === "EOF")
       break;
+    if (t.type === "BLOCK_OPEN" && t.lineStart && scanPos > pos) {
+      const nameResult = parseBlockName(ctx, scanPos + 1);
+      if (nameResult?.name === "div" || nameResult?.name === "div_") {
+        let checkPos = scanPos + 1 + nameResult.consumed;
+        const attrResult = parseAttributes(ctx, checkPos);
+        checkPos += attrResult.consumed;
+        if (ctx.tokens[checkPos]?.type === "BLOCK_CLOSE") {
+          checkPos++;
+          if (ctx.tokens[checkPos]?.type === "NEWLINE" || ctx.tokens[checkPos]?.type === "EOF") {
+            break;
+          }
+        }
+      }
+    }
     if (t.type === "BLOCK_END_OPEN") {
       const nameResult = parseBlockName(ctx, scanPos + 1);
       if (nameResult?.name === "div") {
@@ -2267,6 +2340,23 @@ function consumeFailedDiv(ctx) {
   if (lastClosePos === -1) {
     return { success: false };
   }
+  const endPosForDiag = lastClosePos;
+  for (let diagPos = ctx.pos;diagPos < endPosForDiag; diagPos++) {
+    const t = ctx.tokens[diagPos];
+    if (t?.type === "BLOCK_OPEN") {
+      const nameResult = parseBlockName(ctx, diagPos + 1);
+      if (nameResult?.name === "div" || nameResult?.name === "div_") {
+        if (t.position) {
+          ctx.diagnostics.push({
+            severity: "error",
+            code: "inline-block-element",
+            message: `[[${nameResult.name}]] must be followed by a newline to be a block element`,
+            position: t.position
+          });
+        }
+      }
+    }
+  }
   const endPos = lastClosePos + lastCloseConsumed;
   while (pos < endPos && pos < ctx.tokens.length) {
     const t = ctx.tokens[pos];
@@ -2383,6 +2473,7 @@ var codeBlockRule = {
       consumed++;
     }
     let codeContent = "";
+    let foundClose = closingSwallowed;
     while (!closingSwallowed && pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
       if (!token || token.type === "EOF") {
@@ -2391,6 +2482,7 @@ var codeBlockRule = {
       if (token.type === "BLOCK_END_OPEN") {
         const closeNameResult = parseBlockName(ctx, pos + 1);
         if (closeNameResult && closeNameResult.name === "code") {
+          foundClose = true;
           pos++;
           consumed++;
           pos += closeNameResult.consumed;
@@ -2410,6 +2502,14 @@ var codeBlockRule = {
       pos++;
       consumed++;
     }
+    if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/code]] for [[code]]",
+        position: openToken.position
+      });
+    }
     codeContent = codeContent.replace(/\n$/, "");
     const codeBlockData = {
       contents: codeContent,
@@ -2568,6 +2668,7 @@ var collapsibleRule = {
     }
     pos++;
     consumed++;
+    const openPosition = openToken.position;
     const hasNewlineAfterOpen = ctx.tokens[pos]?.type === "NEWLINE";
     if (hasNewlineAfterOpen) {
       pos++;
@@ -2618,6 +2719,14 @@ var collapsibleRule = {
       pos += bodyResult.consumed;
       bodyElements = mergeParagraphs(bodyResult.elements);
     }
+    if (!isCollapsibleClose(ctx, pos)) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/collapsible]] for [[collapsible]]",
+        position: openPosition
+      });
+    }
     if (isCollapsibleClose(ctx, pos)) {
       const closeConsumed = consumeCloseTag2(ctx, pos);
       consumed += closeConsumed;
@@ -2946,6 +3055,7 @@ var tableBlockRule = {
       consumed++;
     }
     const rows = [];
+    let foundTableClose = false;
     while (pos < ctx.tokens.length) {
       while (ctx.tokens[pos]?.type === "WHITESPACE" || ctx.tokens[pos]?.type === "NEWLINE") {
         pos++;
@@ -2958,6 +3068,7 @@ var tableBlockRule = {
       if (token.type === "BLOCK_END_OPEN") {
         const closeNameResult = parseBlockName(ctx, pos + 1);
         if (closeNameResult?.name === "table") {
+          foundTableClose = true;
           pos++;
           consumed++;
           pos += closeNameResult.consumed;
@@ -2988,6 +3099,14 @@ var tableBlockRule = {
       pos++;
       consumed++;
     }
+    if (!foundTableClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/table]] for [[table]]",
+        position: openToken.position
+      });
+    }
     const hasValidContent = rows.some((row) => row.cells.length > 0);
     if (!hasValidContent) {
       return { success: false };
@@ -3035,6 +3154,7 @@ function parseRow(ctx, startPos) {
     consumed++;
   }
   const cells = [];
+  let foundRowClose = false;
   while (pos < ctx.tokens.length) {
     while (ctx.tokens[pos]?.type === "WHITESPACE" || ctx.tokens[pos]?.type === "NEWLINE") {
       pos++;
@@ -3047,6 +3167,7 @@ function parseRow(ctx, startPos) {
     if (token.type === "BLOCK_END_OPEN") {
       const closeNameResult = parseBlockName(ctx, pos + 1);
       if (closeNameResult?.name === "row") {
+        foundRowClose = true;
         pos++;
         consumed++;
         pos += closeNameResult.consumed;
@@ -3077,6 +3198,17 @@ function parseRow(ctx, startPos) {
     pos++;
     consumed++;
   }
+  if (!foundRowClose) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: "Missing closing tag [[/row]] for [[row]]",
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 }
+      }
+    });
+  }
   return {
     row: {
       attributes: attrResult.attrs,
@@ -3139,6 +3271,17 @@ function parseCell(ctx, startPos) {
   consumed += bodyResult.consumed;
   pos += bodyResult.consumed;
   const hadParagraphBreaks = bodyResult.hadParagraphBreaks;
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: `Missing closing tag [[/${closeName}]] for [[${closeName}]]`,
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 }
+      }
+    });
+  }
   if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
     pos++;
     consumed++;
@@ -3596,6 +3739,7 @@ var moduleRule = {
       pos++;
       consumed++;
       let bodyContent = "";
+      let foundClose = false;
       while (pos < ctx.tokens.length) {
         const token = ctx.tokens[pos];
         if (!token || token.type === "EOF") {
@@ -3604,6 +3748,7 @@ var moduleRule = {
         if (token.type === "BLOCK_END_OPEN") {
           const closeNameResult = parseBlockName(ctx, pos + 1);
           if (closeNameResult && (closeNameResult.name === "module" || closeNameResult.name === "module654")) {
+            foundClose = true;
             pos++;
             consumed++;
             pos += closeNameResult.consumed;
@@ -3623,6 +3768,14 @@ var moduleRule = {
         pos++;
         consumed++;
       }
+      if (!foundClose) {
+        ctx.diagnostics.push({
+          severity: "warning",
+          code: "unclosed-block",
+          message: "Missing closing tag [[/module]] for [[module]]",
+          position: openToken.position
+        });
+      }
       if (bodyContent.trim()) {
         body = bodyContent.trim();
       }
@@ -4016,7 +4169,16 @@ var alignRule = {
     const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
     consumed += bodyResult.consumed;
     pos += bodyResult.consumed;
+    const directionSymbol = { left: "<", right: ">", center: "=", justify: "==" }[direction];
     const closeCheck = isAlignClose({ ...ctx, pos }, direction);
+    if (!closeCheck.match) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/${directionSymbol}]] for [[${directionSymbol}]]`,
+        position: openToken.position
+      });
+    }
     if (closeCheck.match) {
       consumed += closeCheck.consumed;
       pos += closeCheck.consumed;
@@ -4104,6 +4266,17 @@ function parseTab(ctx) {
   const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
   consumed += bodyResult.consumed;
   pos += bodyResult.consumed;
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: "Missing closing tag [[/tab]] for [[tab]]",
+      position: ctx.tokens[ctx.pos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 }
+      }
+    });
+  }
   if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
     pos++;
     consumed++;
@@ -4167,6 +4340,9 @@ var tabviewRule = {
     const tabs = [];
     const tabCtx = { ...ctx, pos };
     while (pos < ctx.tokens.length) {
+      if (ctx.tokens[pos]?.type === "EOF") {
+        break;
+      }
       if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
         const closeNameResult = parseBlockName(ctx, pos + 1);
         const closeName = closeNameResult?.name.toLowerCase();
@@ -4188,6 +4364,19 @@ var tabviewRule = {
         }
       }
     }
+    const hasTabviewClose = ctx.tokens[pos]?.type === "BLOCK_END_OPEN" && (() => {
+      const n = parseBlockName(ctx, pos + 1);
+      const name = n?.name.toLowerCase();
+      return name === "tabview" || name === "tabs";
+    })();
+    if (!hasTabviewClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/${blockName}]] for [[${blockName}]]`,
+        position: openToken.position
+      });
+    }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
       pos++;
       consumed++;
@@ -4426,6 +4615,14 @@ var mathBlockRule = {
       pos++;
       consumed++;
     }
+    if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/math]] for [[math]]",
+        position: openToken.position
+      });
+    }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
       pos++;
       consumed++;
@@ -4508,6 +4705,12 @@ var htmlBlockRule = {
       consumed++;
     }
     if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/html]] for [[html]]",
+        position: openToken.position
+      });
       return { success: false };
     }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
@@ -4597,6 +4800,12 @@ var embedBlockRule = {
       consumed++;
     }
     if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/${blockName}]] for [[${blockName}]]`,
+        position: openToken.position
+      });
       return { success: false };
     }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
@@ -4826,6 +5035,14 @@ var iftagsRule = {
     const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
     consumed += bodyResult.consumed;
     pos += bodyResult.consumed;
+    if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/iftags]] for [[iftags]]",
+        position: openToken.position
+      });
+    }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
       pos++;
       consumed++;
@@ -5029,6 +5246,12 @@ var orphanLiRule = {
       consumed++;
     }
     if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/li]] for [[li]]",
+        position: openToken.position
+      });
       return { success: false };
     }
     return {
@@ -5219,6 +5442,12 @@ var bibliographyRule = {
       consumed++;
     }
     if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/bibliography]] for [[bibliography]]",
+        position: openToken.position
+      });
       return { success: false };
     }
     const definitionItems = entries.map((entry) => ({
@@ -6140,6 +6369,7 @@ var commentRule = {
   name: "comment",
   startTokens: ["COMMENT_OPEN"],
   parse(ctx) {
+    const openToken = currentToken(ctx);
     let pos = ctx.pos + 1;
     let consumed = 1;
     while (pos < ctx.tokens.length) {
@@ -6157,11 +6387,23 @@ var commentRule = {
         };
       }
       if (token.type === "EOF") {
+        ctx.diagnostics.push({
+          severity: "warning",
+          code: "unclosed-comment",
+          message: "Unterminated comment: missing closing --]",
+          position: openToken.position
+        });
         return { success: false };
       }
       pos++;
       consumed++;
     }
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-comment",
+      message: "Unterminated comment: missing closing --]",
+      position: openToken.position
+    });
     return { success: false };
   }
 };
@@ -6419,6 +6661,12 @@ var spanRule = {
       }
     }
     if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/span]] for [[${blockName}]]`,
+        position: openToken.position
+      });
       return { success: false };
     }
     if (paragraphStrip) {
@@ -6619,6 +6867,7 @@ var sizeRule = {
     pos++;
     consumed++;
     const children = [];
+    let foundClose = false;
     while (pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
       if (!token || token.type === "EOF") {
@@ -6627,6 +6876,7 @@ var sizeRule = {
       if (token.type === "BLOCK_END_OPEN") {
         const closeNameResult = parseBlockName(ctx, pos + 1);
         if (closeNameResult && closeNameResult.name === "size") {
+          foundClose = true;
           pos++;
           consumed++;
           pos += closeNameResult.consumed;
@@ -6650,6 +6900,14 @@ var sizeRule = {
         consumed++;
       }
     }
+    if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/size]] for [[size]]",
+        position: openToken.position
+      });
+    }
     return {
       success: true,
       elements: [
@@ -6699,6 +6957,7 @@ var footnoteRule = {
     consumed++;
     const paragraphs = [[]];
     let currentParagraph = 0;
+    let foundClose = false;
     while (pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
       if (!token || token.type === "EOF") {
@@ -6707,6 +6966,7 @@ var footnoteRule = {
       if (token.type === "BLOCK_END_OPEN") {
         const closeNameResult = parseBlockName(ctx, pos + 1);
         if (closeNameResult && closeNameResult.name === "footnote") {
+          foundClose = true;
           pos++;
           consumed++;
           pos += closeNameResult.consumed;
@@ -6783,6 +7043,14 @@ var footnoteRule = {
         });
       }
     }
+    if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/footnote]] for [[footnote]]",
+        position: openToken.position
+      });
+    }
     ctx.footnotes.push(children);
     return {
       success: true,
@@ -7278,6 +7546,12 @@ var anchorRule = {
       }
     }
     if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/a]] for [[${nameResult.name}]]`,
+        position: openToken.position
+      });
       return { success: false };
     }
     if (paragraphStrip) {
@@ -8256,6 +8530,50 @@ function cleanElement(el) {
   }
   return el;
 }
+// packages/parser/src/parser/postprocess/divAdjacentParagraph.ts
+function isParagraphContainer2(el) {
+  if (!el || el.element !== "container")
+    return false;
+  return el.data.type === "paragraph";
+}
+function isDivContainer(el) {
+  if (!el || el.element !== "container")
+    return false;
+  return el.data.type === "div";
+}
+function suppressAtLevel(elements) {
+  if (elements.length <= 1)
+    return elements;
+  const unwrap = new Array(elements.length).fill(false);
+  for (let i = 0;i < elements.length; i++) {
+    if (!isParagraphContainer2(elements[i]))
+      continue;
+    const prevIsDiv = i > 0 && isDivContainer(elements[i - 1]);
+    const nextIsDiv = i < elements.length - 1 && isDivContainer(elements[i + 1]);
+    if (prevIsDiv || nextIsDiv) {
+      unwrap[i] = true;
+    }
+  }
+  const result = [];
+  for (let i = 0;i < elements.length; i++) {
+    const el = elements[i];
+    if (!el)
+      continue;
+    if (unwrap[i] && el.element === "container") {
+      const inner = el.data.elements;
+      if (i > 0 && isDivContainer(elements[i - 1])) {
+        result.push({ element: "line-break" });
+      }
+      result.push(...inner);
+    } else {
+      result.push(el);
+    }
+  }
+  return result;
+}
+function suppressDivAdjacentParagraphs(elements) {
+  return suppressAtLevel(elements);
+}
 // packages/parser/src/parser/toc.ts
 class TocIndexer {
   index = 0;
@@ -8333,6 +8651,7 @@ class Parser {
       htmlBlocks: [],
       footnoteBlockParsed: false,
       bibcites: [],
+      diagnostics: [],
       blockRules,
       blockFallbackRule: paragraphRule,
       inlineRules
@@ -8345,7 +8664,8 @@ class Parser {
       children.push(...blocks);
     }
     const mergedChildren = mergeSpanStripParagraphs(children);
-    const cleanedChildren = cleanInternalFlags(mergedChildren);
+    const divProcessed = suppressDivAdjacentParagraphs(mergedChildren);
+    const cleanedChildren = cleanInternalFlags(divProcessed);
     const hasFootnoteBlock = cleanedChildren.some((el) => el.element === "footnote-block");
     if (!hasFootnoteBlock) {
       cleanedChildren.push({
@@ -8369,7 +8689,7 @@ class Parser {
     if (this.ctx.htmlBlocks.length > 0) {
       result["html-blocks"] = this.ctx.htmlBlocks;
     }
-    return result;
+    return { ast: result, diagnostics: this.ctx.diagnostics };
   }
   isAtEnd() {
     return this.ctx.pos >= this.ctx.tokens.length || this.currentToken().type === "EOF";
@@ -9580,6 +9900,7 @@ function resolveAndNormalizeQuery(requirement, urlParams) {
 function parseTagCondition(condition) {
   const required = [];
   const forbidden = [];
+  const optional = [];
   const parts = condition.trim().split(/\s+/);
   for (const part of parts) {
     if (!part)
@@ -9593,12 +9914,15 @@ function parseTagCondition(condition) {
       if (tag)
         forbidden.push(tag);
     } else {
-      required.push(part);
+      optional.push(part);
     }
   }
-  return { required, forbidden };
+  return { required, forbidden, optional };
 }
 function evaluateTagCondition(condition, pageTags) {
+  if (condition.required.length === 0 && condition.forbidden.length === 0 && condition.optional.length === 0) {
+    return false;
+  }
   const tagSet = new Set(pageTags);
   for (const tag of condition.required) {
     if (!tagSet.has(tag)) {
@@ -9610,6 +9934,11 @@ function evaluateTagCondition(condition, pageTags) {
       return false;
     }
   }
+  if (condition.optional.length > 0) {
+    if (!condition.optional.some((tag) => tagSet.has(tag))) {
+      return false;
+    }
+  }
   return true;
 }
 // packages/parser/src/parser/rules/block/module/iftags/resolve.ts
@@ -9745,6 +10074,7 @@ function resolveListUsers(_module, data, compiledTemplate, parse2) {
   return itemAst.elements;
 }
 // packages/parser/src/parser/rules/block/module/resolve.ts
+var import_ast3 = require("@wdprlib/ast");
 async function resolveModules(ast, dataProvider, options) {
   let listPagesCtx = null;
   const listPagesReqs = options.requirements.listPages ?? [];
@@ -9909,18 +10239,31 @@ function countModulesInElements(elements) {
 }
 function collectStyles(elements) {
   const styles = [];
-  const filtered = collectStylesFromElements(elements, styles);
+  const ctx = { nextSlotId: 0 };
+  const filtered = collectStylesFromElements(elements, styles, ctx);
   return { elements: filtered, styles };
 }
-function collectStylesFromElements(elements, styles) {
+function collectStylesFromElements(elements, styles, ctx) {
   const result = [];
   for (const element of elements) {
     if (element.element === "style") {
       styles.push(element.data);
       continue;
     }
-    const mapped = mapElementChildren(element, (children) => collectStylesFromElements(children, styles));
+    if (element.element === "if-tags") {
+      const slotId = ctx.nextSlotId++;
+      styles.push(`${import_ast3.STYLE_SLOT_PREFIX}${slotId}`);
+      result.push({
+        element: "if-tags",
+        data: { ...element.data, _styleSlot: slotId }
+      });
+      continue;
+    }
+    const mapped = mapElementChildren(element, (children) => collectStylesFromElements(children, styles, ctx));
     result.push(mapped);
   }
   return result;
 }
+
+// packages/parser/src/parser/rules/block/module/index.ts
+var import_ast4 = require("@wdprlib/ast");