@wdprlib/parser 1.1.4 → 2.0.2

package/README.md

@@ -1,6 +1,6 @@
 # @wdprlib/parser
 
-Wikidot markup parser.
+Parser for Wikidot markup.
 
 ## Installation
 
@@ -56,6 +56,7 @@ const resolved = await resolveModules(ast, {
 
 - [@wdprlib/ast](https://www.npmjs.com/package/@wdprlib/ast) - AST type definitions
 - [@wdprlib/render](https://www.npmjs.com/package/@wdprlib/render) - HTML renderer
+- [@wdprlib/decompiler](https://www.npmjs.com/package/@wdprlib/decompiler) - HTML to Wikidot decompiler
 - [@wdprlib/runtime](https://www.npmjs.com/package/@wdprlib/runtime) - Client-side runtime
 
 ## License

package/dist/index.cjs

@@ -1528,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;
@@ -1620,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;
@@ -1748,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,
@@ -2183,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") {
@@ -2195,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);
@@ -2208,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++;
@@ -2241,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;
@@ -2252,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") {
@@ -2268,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];
@@ -2384,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") {
@@ -2392,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;
@@ -2411,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,
@@ -2569,6 +2668,7 @@ var collapsibleRule = {
     }
     pos++;
     consumed++;
+    const openPosition = openToken.position;
     const hasNewlineAfterOpen = ctx.tokens[pos]?.type === "NEWLINE";
     if (hasNewlineAfterOpen) {
       pos++;
@@ -2619,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;
@@ -2947,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++;
@@ -2959,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;
@@ -2989,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 };
@@ -3036,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++;
@@ -3048,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;
@@ -3078,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,
@@ -3140,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++;
@@ -3597,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") {
@@ -3605,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;
@@ -3624,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();
       }
@@ -4017,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;
@@ -4105,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++;
@@ -4168,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();
@@ -4189,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++;
@@ -4427,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++;
@@ -4509,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") {
@@ -4598,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") {
@@ -4827,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++;
@@ -5030,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 {
@@ -5220,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) => ({
@@ -6141,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) {
@@ -6158,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 };
   }
 };
@@ -6420,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) {
@@ -6620,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") {
@@ -6628,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;
@@ -6651,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: [
@@ -6700,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") {
@@ -6708,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;
@@ -6784,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,
@@ -7279,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) {
@@ -8257,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;
@@ -8334,6 +8651,7 @@ class Parser {
       htmlBlocks: [],
       footnoteBlockParsed: false,
       bibcites: [],
+      diagnostics: [],
       blockRules,
       blockFallbackRule: paragraphRule,
       inlineRules
@@ -8346,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({
@@ -8370,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";