@wdprlib/parser 1.1.4 → 2.0.0

package/dist/index.js

@@ -1473,6 +1473,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;
@@ -1565,11 +1576,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;
@@ -1693,6 +1706,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,
@@ -2128,8 +2152,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") {
@@ -2140,7 +2175,7 @@ var divRule = {
       }
       return false;
     };
-    const bodyCtx = { ...ctx, pos };
+    const bodyCtx = { ...ctx, pos, divClosesBudget: bodyBudget };
     let children;
     if (paragraphStrip) {
       const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
@@ -2153,6 +2188,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++;
@@ -2186,6 +2229,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;
@@ -2197,6 +2255,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") {
@@ -2213,6 +2285,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];
@@ -2329,6 +2418,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") {
@@ -2337,6 +2427,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;
@@ -2356,6 +2447,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,
@@ -2514,6 +2613,7 @@ var collapsibleRule = {
     }
     pos++;
     consumed++;
+    const openPosition = openToken.position;
     const hasNewlineAfterOpen = ctx.tokens[pos]?.type === "NEWLINE";
     if (hasNewlineAfterOpen) {
       pos++;
@@ -2564,6 +2664,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;
@@ -2892,6 +3000,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++;
@@ -2904,6 +3013,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;
@@ -2934,6 +3044,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 };
@@ -2981,6 +3099,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++;
@@ -2993,6 +3112,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;
@@ -3023,6 +3143,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,
@@ -3085,6 +3216,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++;
@@ -3542,6 +3684,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") {
@@ -3550,6 +3693,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;
@@ -3569,6 +3713,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();
       }
@@ -3962,7 +4114,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;
@@ -4050,6 +4211,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++;
@@ -4113,6 +4285,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();
@@ -4134,6 +4309,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++;
@@ -4372,6 +4560,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++;
@@ -4454,6 +4650,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") {
@@ -4543,6 +4745,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") {
@@ -4772,6 +4980,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++;
@@ -4975,6 +5191,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 {
@@ -5165,6 +5387,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) => ({
@@ -6086,6 +6314,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) {
@@ -6103,11 +6332,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 };
   }
 };
@@ -6365,6 +6606,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) {
@@ -6565,6 +6812,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") {
@@ -6573,6 +6821,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;
@@ -6596,6 +6845,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: [
@@ -6645,6 +6902,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") {
@@ -6653,6 +6911,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;
@@ -6729,6 +6988,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,
@@ -7224,6 +7491,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) {
@@ -8202,6 +8475,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;
@@ -8279,6 +8596,7 @@ class Parser {
       htmlBlocks: [],
       footnoteBlockParsed: false,
       bibcites: [],
+      diagnostics: [],
       blockRules,
       blockFallbackRule: paragraphRule,
       inlineRules
@@ -8291,7 +8609,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({
@@ -8315,7 +8634,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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdprlib/parser",
-  "version": "1.1.4",
+  "version": "2.0.0",
   "description": "Parser for Wikidot markup",
   "keywords": [
     "ast",
@@ -39,6 +39,6 @@
   },
   "dependencies": {
     "@braintree/sanitize-url": "^7.1.1",
-    "@wdprlib/ast": "1.1.1"
+    "@wdprlib/ast": "1.2.0"
   }
 }