@wdprlib/parser 0.1.5 → 1.0.0

package/dist/index.js

@@ -25,6 +25,7 @@ import { createPoint, createPosition } from "@wdprlib/ast";
 class Lexer {
   state;
   options;
+  splitBlockClosePositions = new Set;
   constructor(source, options = {}) {
     this.options = {
       trackPositions: options.trackPositions ?? true
@@ -51,6 +52,37 @@ class Lexer {
   current() {
     return this.state.source[this.state.pos] ?? "";
   }
+  findInvalidAnchorNameEnd() {
+    const src = this.state.source;
+    const pos = this.state.pos;
+    if (src[pos] !== "[" || src[pos + 1] !== "[" || src[pos + 2] !== "#") {
+      return null;
+    }
+    if (src[pos + 3] !== " ") {
+      return null;
+    }
+    let i = pos + 4;
+    while (i < src.length && src[i] === " ") {
+      i++;
+    }
+    let foundInvalid = false;
+    while (i < src.length) {
+      const ch = src[i];
+      if (ch === `
+`)
+        return null;
+      if (ch === "]" && src[i + 1] === "]") {
+        return foundInvalid ? i : null;
+      }
+      const code = ch.charCodeAt(0);
+      const isValid = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 45 || code === 95 || code === 46 || code === 37;
+      if (!isValid) {
+        foundInvalid = true;
+      }
+      i++;
+    }
+    return null;
+  }
   match(pattern) {
     for (let i = 0;i < pattern.length; i++) {
       if (this.state.source[this.state.pos + i] !== pattern[i]) {
@@ -120,6 +152,13 @@ class Lexer {
       return;
     }
     if (this.match("[[")) {
+      const invalidEnd = this.findInvalidAnchorNameEnd();
+      if (invalidEnd !== null) {
+        this.splitBlockClosePositions.add(invalidEnd);
+        this.advance(1);
+        this.addToken("TEXT", "[");
+        return;
+      }
       this.advance(2);
       this.addToken("BLOCK_OPEN", "[[");
       return;
@@ -130,6 +169,14 @@ class Lexer {
       return;
     }
     if (this.match("]]")) {
+      if (this.splitBlockClosePositions.has(this.state.pos)) {
+        this.splitBlockClosePositions.delete(this.state.pos);
+        this.advance(1);
+        this.addToken("BRACKET_CLOSE", "]");
+        this.advance(1);
+        this.addToken("TEXT", "]");
+        return;
+      }
       this.advance(2);
       this.addToken("BLOCK_CLOSE", "]]");
       return;
@@ -164,7 +211,7 @@ class Lexer {
       this.addToken("BOLD_MARKER", "**");
       return;
     }
-    if (isLineStart && this.match("---")) {
+    if (isLineStart && this.match("----")) {
       let dashes = "";
       while (this.current() === "-") {
         dashes += this.advance();
@@ -379,6 +426,11 @@ class Lexer {
       this.addToken("BACKSLASH", "\\");
       return;
     }
+    if (char.charCodeAt(0) === 57344) {
+      this.advance();
+      this.addToken("BACKSLASH_BREAK", char);
+      return;
+    }
     if (this.isAlphanumeric(char)) {
       let ident = "";
       while (!this.isAtEnd() && this.isAlphanumeric(this.current())) {
@@ -418,7 +470,7 @@ function substitute(text) {
 `);
   result = replaceLeadingSpaces(result);
   result = result.replace(WHITESPACE_ONLY_LINE, "");
-  result = result.replace(CONCAT_LINES, "");
+  result = result.replace(CONCAT_LINES, String.fromCharCode(57344));
   result = result.replace(TABS, "    ");
   result = result.replace(NULL_CHARS, " ");
   result = result.replace(LEADING_NEWLINES, "");
@@ -588,9 +640,42 @@ function parseInlineUntil(ctx, endType) {
             isInvalidBlockOpen = true;
           }
         }
+        let skipWhitespace = 0;
+        while (ctx.tokens[afterOpen + skipWhitespace]?.type === "WHITESPACE") {
+          skipWhitespace++;
+        }
+        const blockNameToken = ctx.tokens[afterOpen + skipWhitespace];
+        if (blockNameToken && (blockNameToken.type === "TEXT" || blockNameToken.type === "IDENTIFIER") && blockNameToken.value.toLowerCase() === "footnoteblock" && ctx.footnoteBlockParsed) {
+          isInvalidBlockOpen = true;
+        }
+      }
+      let isInvalidHeading = false;
+      if (nextMeaningfulToken?.type === "HEADING_MARKER") {
+        const markerLen = nextMeaningfulToken.value.length;
+        const afterMarkerPos = pos + lookAhead + 1;
+        const afterMarker = ctx.tokens[afterMarkerPos];
+        if (markerLen > 6) {
+          isInvalidHeading = true;
+        } else if (afterMarker?.type === "STAR") {
+          const afterStar = ctx.tokens[afterMarkerPos + 1];
+          if (afterStar?.type !== "WHITESPACE") {
+            isInvalidHeading = true;
+          }
+        } else if (afterMarker?.type !== "WHITESPACE") {
+          isInvalidHeading = true;
+        }
       }
-      const isBlockStart = nextMeaningfulToken && BLOCK_START_TOKENS.includes(nextMeaningfulToken.type) && nextMeaningfulToken.lineStart && !isOrphanCloseSpan && !isAnchorName && !isInvalidBlockOpen;
+      const isBlockStart = nextMeaningfulToken && BLOCK_START_TOKENS.includes(nextMeaningfulToken.type) && nextMeaningfulToken.lineStart && !isOrphanCloseSpan && !isAnchorName && !isInvalidBlockOpen && !isInvalidHeading;
       if (!nextMeaningfulToken || nextMeaningfulToken.type === "NEWLINE" || nextMeaningfulToken.type === "EOF" || isBlockStart) {
+        if (isBlockStart && nodes.length > 0) {
+          const nextPos = pos + lookAhead;
+          const shouldPreserve = ctx.blockRules.some((rule) => rule.preservesPrecedingLineBreak && rule.isStartPattern?.(ctx, nextPos));
+          if (shouldPreserve) {
+            const lb = { element: "line-break" };
+            lb._preservedTrailingBreak = true;
+            nodes.push(lb);
+          }
+        }
         consumed++;
         if (nextMeaningfulToken?.type === "NEWLINE") {
           consumed++;
@@ -651,7 +736,10 @@ var headingRule = {
     if (ctx.tokens[pos]?.type !== "WHITESPACE") {
       return { success: false };
     }
-    const depth = Math.min(marker.value.length, 6);
+    if (marker.value.length > 6) {
+      return { success: false };
+    }
+    const depth = marker.value.length;
     while (ctx.tokens[pos]?.type === "WHITESPACE") {
       pos++;
       consumed++;
@@ -1024,10 +1112,6 @@ function filterUnsafeAttributes(attrs) {
 function parseBlockName(ctx, startPos) {
   let pos = startPos;
   let consumed = 0;
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
   const token = ctx.tokens[pos];
   if (!token || token.type !== "TEXT" && token.type !== "IDENTIFIER") {
     return null;
@@ -1104,79 +1188,6 @@ function parseBlocksUntil(ctx, closeCondition) {
   }
   return { elements, consumed };
 }
-function parseInlineContentUntil(ctx, closeCondition) {
-  const elements = [];
-  let consumed = 0;
-  let pos = ctx.pos;
-  const { blockRules, inlineRules } = ctx;
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token || token.type === "EOF") {
-      break;
-    }
-    const checkCtx = { ...ctx, pos };
-    if (closeCondition(checkCtx)) {
-      break;
-    }
-    if (token.type === "WHITESPACE" && token.lineStart) {
-      pos++;
-      consumed++;
-      continue;
-    }
-    if (token.type === "NEWLINE") {
-      pos++;
-      consumed++;
-      while (ctx.tokens[pos]?.type === "NEWLINE") {
-        pos++;
-        consumed++;
-      }
-      const nextToken = ctx.tokens[pos];
-      if (nextToken?.type === "BLOCK_OPEN" || nextToken?.type === "BLOCK_END_OPEN" || nextToken?.type === "EOF" || !nextToken) {
-        continue;
-      }
-      elements.push({ element: "line-break" });
-      continue;
-    }
-    let matched = false;
-    const blockCtx = { ...ctx, pos };
-    for (const rule of blockRules) {
-      if (canApplyBlockRule(rule, token)) {
-        const result = rule.parse(blockCtx);
-        if (result.success) {
-          elements.push(...result.elements);
-          consumed += result.consumed;
-          pos += result.consumed;
-          matched = true;
-          break;
-        }
-      }
-    }
-    if (matched)
-      continue;
-    const inlineCtx = { ...ctx, pos };
-    for (const rule of inlineRules) {
-      if (canApplyInlineRule(rule, token)) {
-        const result = rule.parse(inlineCtx);
-        if (result.success) {
-          elements.push(...result.elements);
-          consumed += result.consumed;
-          pos += result.consumed;
-          matched = true;
-          break;
-        }
-      }
-    }
-    if (!matched) {
-      elements.push({ element: "text", data: token.value });
-      consumed++;
-      pos++;
-    }
-  }
-  while (elements.length > 0 && elements[elements.length - 1]?.element === "line-break") {
-    elements.pop();
-  }
-  return { elements, consumed };
-}
 function parseAttributes(ctx, startPos) {
   const attrs = {};
   let pos = startPos;
@@ -1325,7 +1336,7 @@ function isLiOpen(ctx, pos) {
   const nameResult = parseBlockName(ctx, pos + 1);
   if (!nameResult)
     return null;
-  if (nameResult.name === "li" || nameResult.name === "li_") {
+  if (nameResult.name === "li") {
     return { name: nameResult.name, consumed: 1 + nameResult.consumed };
   }
   return null;
@@ -1358,7 +1369,6 @@ function parseLiItem(ctx, startPos, listType) {
   const liOpen = isLiOpen(ctx, pos);
   if (!liOpen)
     return null;
-  const isParagraphStrip = liOpen.name === "li_";
   pos += liOpen.consumed;
   consumed += liOpen.consumed;
   const attrResult = parseAttributes(ctx, pos);
@@ -1404,13 +1414,23 @@ function parseLiItem(ctx, startPos, listType) {
     if (token.type === "NEWLINE") {
       pos++;
       consumed++;
+      let consecutiveNewlines = 1;
       while (ctx.tokens[pos]?.type === "NEWLINE") {
         pos++;
         consumed++;
+        consecutiveNewlines++;
       }
-      if (isParagraphStrip && !isLiClose(ctx, pos) && !isListClose(ctx, pos, listType) && !isNestedListOpen(ctx, pos) && ctx.tokens[pos]?.type !== "EOF") {
+      while (ctx.tokens[pos]?.type === "WHITESPACE" && ctx.tokens[pos]?.lineStart) {
+        pos++;
+        consumed++;
+      }
+      const atCloseTag = isLiClose(ctx, pos) || isListClose(ctx, pos, listType) || ctx.tokens[pos]?.type === "EOF";
+      if (consecutiveNewlines === 1 && contentElements.length > 0) {
         contentElements.push({ element: "line-break" });
       }
+      if (atCloseTag) {
+        continue;
+      }
       continue;
     }
     let matched = false;
@@ -1453,6 +1473,57 @@ function parseLiItem(ctx, startPos, listType) {
     const closeConsumed = consumeCloseTag(ctx, pos);
     consumed += closeConsumed;
     pos += closeConsumed;
+    while (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+    while (pos < ctx.tokens.length) {
+      const tok = ctx.tokens[pos];
+      if (!tok || tok.type === "EOF")
+        break;
+      if (tok.type === "NEWLINE") {
+        pos++;
+        consumed++;
+        while (ctx.tokens[pos]?.type === "NEWLINE") {
+          pos++;
+          consumed++;
+        }
+        while (ctx.tokens[pos]?.type === "WHITESPACE" && ctx.tokens[pos]?.lineStart) {
+          pos++;
+          consumed++;
+        }
+        if (isLiOpen(ctx, pos) || isListClose(ctx, pos, listType) || isNestedListOpen(ctx, pos) || ctx.tokens[pos]?.type === "EOF") {
+          break;
+        }
+        continue;
+      }
+      if (isLiOpen(ctx, pos) || isListClose(ctx, pos, listType) || isNestedListOpen(ctx, pos)) {
+        break;
+      }
+      let matched = false;
+      const inlineCtx = { ...ctx, pos };
+      for (const rule of ctx.inlineRules) {
+        if (rule.startTokens.includes(tok.type)) {
+          const result = rule.parse(inlineCtx);
+          if (result.success) {
+            contentElements.push(...result.elements);
+            consumed += result.consumed;
+            pos += result.consumed;
+            matched = true;
+            break;
+          }
+        }
+      }
+      if (!matched) {
+        contentElements.push({ element: "text", data: tok.value });
+        consumed++;
+        pos++;
+      }
+    }
   }
   return {
     item: {
@@ -1533,8 +1604,90 @@ function parseListBlock(ctx, startPos, listType) {
       pos += liResult.consumed;
       continue;
     }
-    pos++;
-    consumed++;
+    const bareContent = [];
+    let currentParagraph = [];
+    const flushParagraph = () => {
+      if (currentParagraph.length > 0) {
+        while (currentParagraph.length > 0 && currentParagraph[currentParagraph.length - 1]?.element === "line-break") {
+          currentParagraph.pop();
+        }
+        if (currentParagraph.length > 0) {
+          bareContent.push({
+            element: "container",
+            data: {
+              type: "paragraph",
+              attributes: {},
+              elements: currentParagraph
+            }
+          });
+        }
+        currentParagraph = [];
+      }
+    };
+    while (pos < ctx.tokens.length) {
+      const tok = ctx.tokens[pos];
+      if (!tok || tok.type === "EOF")
+        break;
+      if (tok.type === "NEWLINE") {
+        pos++;
+        consumed++;
+        let consecutiveNewlines = 1;
+        while (ctx.tokens[pos]?.type === "NEWLINE") {
+          pos++;
+          consumed++;
+          consecutiveNewlines++;
+        }
+        while (ctx.tokens[pos]?.type === "WHITESPACE" && ctx.tokens[pos]?.lineStart) {
+          pos++;
+          consumed++;
+        }
+        if (isListClose(ctx, pos, listType) || isLiOpen(ctx, pos) || isNestedListOpen(ctx, pos)) {
+          break;
+        }
+        if (consecutiveNewlines >= 2) {
+          flushParagraph();
+        } else if (currentParagraph.length > 0) {
+          currentParagraph.push({ element: "line-break" });
+        }
+        continue;
+      }
+      if (isListClose(ctx, pos, listType) || isLiOpen(ctx, pos) || isNestedListOpen(ctx, pos)) {
+        break;
+      }
+      let matched = false;
+      const inlineCtx = { ...ctx, pos };
+      for (const rule of ctx.inlineRules) {
+        if (rule.startTokens.includes(tok.type)) {
+          const result = rule.parse(inlineCtx);
+          if (result.success) {
+            currentParagraph.push(...result.elements);
+            consumed += result.consumed;
+            pos += result.consumed;
+            matched = true;
+            break;
+          }
+        }
+      }
+      if (!matched) {
+        currentParagraph.push({ element: "text", data: tok.value });
+        consumed++;
+        pos++;
+      }
+    }
+    flushParagraph();
+    if (bareContent.length > 0) {
+      let finalElements;
+      if (bareContent.length === 1 && bareContent[0]?.element === "container" && bareContent[0].data?.type === "paragraph") {
+        finalElements = bareContent[0].data.elements;
+      } else {
+        finalElements = bareContent;
+      }
+      items.push({
+        "item-type": "elements",
+        attributes: { _noMarker: "true" },
+        elements: finalElements
+      });
+    }
   }
   const listData = {
     type: listType === "ol" ? "numbered" : "bullet",
@@ -1590,21 +1743,6 @@ var blockquoteRule = {
     let pos = ctx.pos;
     let consumed = 0;
     while (pos < ctx.tokens.length) {
-      while (ctx.tokens[pos]?.type === "NEWLINE" && ctx.tokens[pos]?.lineStart) {
-        const nextPos = pos + 1;
-        const nextToken = ctx.tokens[nextPos];
-        if (nextToken?.type === "BLOCKQUOTE_MARKER" && nextToken.lineStart) {
-          depths.push({
-            depth: 0,
-            ltype: null,
-            value: { elements: [], hasLineBreak: false }
-          });
-          pos++;
-          consumed++;
-        } else {
-          break;
-        }
-      }
       const markerToken = ctx.tokens[pos];
       if (!markerToken || !markerToken.lineStart || markerToken.type !== "BLOCKQUOTE_MARKER") {
         break;
@@ -1615,6 +1753,17 @@ var blockquoteRule = {
       }
       pos++;
       consumed++;
+      if (ctx.tokens[pos]?.type !== "WHITESPACE") {
+        while (pos < ctx.tokens.length && ctx.tokens[pos]?.type !== "NEWLINE") {
+          pos++;
+          consumed++;
+        }
+        if (ctx.tokens[pos]?.type === "NEWLINE") {
+          pos++;
+          consumed++;
+        }
+        continue;
+      }
       while (ctx.tokens[pos]?.type === "WHITESPACE") {
         pos++;
         consumed++;
@@ -1637,6 +1786,9 @@ var blockquoteRule = {
       });
     }
     if (depths.length === 0) {
+      if (consumed > 0) {
+        return { success: true, elements: [], consumed };
+      }
       return { success: false };
     }
     const depthTrees = processDepths(null, depths);
@@ -1674,6 +1826,10 @@ function buildBlockquoteElement(list) {
   }
   for (const item of list) {
     if (item.kind === "item") {
+      if (item.value.elements.length === 0) {
+        flushParagraph();
+        continue;
+      }
       currentParagraphChildren.push(...item.value.elements);
       if (item.value.hasLineBreak) {
         currentParagraphChildren.push({ element: "line-break" });
@@ -1884,14 +2040,36 @@ var paragraphRule = {
     }
     let elements = processCloseSpanMarkers(result.elements);
     while (elements.length > 0 && elements[elements.length - 1]?.element === "line-break") {
+      const lastEl = elements[elements.length - 1];
+      if (lastEl._preservedTrailingBreak) {
+        delete lastEl._preservedTrailingBreak;
+        break;
+      }
       elements.pop();
     }
+    while (elements.length > 0) {
+      const last = elements[elements.length - 1];
+      if (last?.element === "text" && "data" in last && typeof last.data === "string" && last.data.trim() === "") {
+        elements.pop();
+      } else {
+        break;
+      }
+    }
     while (elements.length > 0 && elements[0]?.element === "line-break") {
       elements.shift();
     }
     if (elements.length === 0) {
       return { success: false };
     }
+    const nextPos = ctx.pos + result.consumed;
+    const nextToken = ctx.tokens[nextPos];
+    if (nextToken?.type === "COLON" && nextToken.lineStart) {
+      return {
+        success: true,
+        elements: [...elements, { element: "line-break" }],
+        consumed: result.consumed
+      };
+    }
     return {
       success: true,
       elements: [
@@ -1944,7 +2122,7 @@ var divRule = {
     pos++;
     consumed++;
     if (ctx.tokens[pos]?.type !== "NEWLINE") {
-      return { success: false };
+      return consumeFailedDiv(ctx);
     }
     pos++;
     consumed++;
@@ -1961,10 +2139,10 @@ var divRule = {
     const bodyCtx = { ...ctx, pos };
     let children;
     if (paragraphStrip) {
-      const bodyResult = parseInlineContentUntil(bodyCtx, closeCondition);
+      const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
       consumed += bodyResult.consumed;
       pos += bodyResult.consumed;
-      children = bodyResult.elements;
+      children = unwrapEdgeParagraphs(bodyResult.elements);
     } else {
       const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
       consumed += bodyResult.consumed;
@@ -2004,28 +2182,117 @@ var divRule = {
     };
   }
 };
-
-// packages/parser/src/parser/rules/block/code.ts
-var codeBlockRule = {
-  name: "code",
-  startTokens: ["BLOCK_OPEN"],
-  requiresLineStart: false,
-  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) {
-      return { success: false };
-    }
-    if (nameResult.name !== "code") {
-      return { success: false };
+function consumeFailedDiv(ctx) {
+  const elements = [];
+  let pos = ctx.pos;
+  let consumed = 0;
+  let lastClosePos = -1;
+  let lastCloseConsumed = 0;
+  let scanPos = pos;
+  while (scanPos < ctx.tokens.length) {
+    const t = ctx.tokens[scanPos];
+    if (!t || t.type === "EOF")
+      break;
+    if (t.type === "BLOCK_END_OPEN") {
+      const nameResult = parseBlockName(ctx, scanPos + 1);
+      if (nameResult?.name === "div") {
+        lastClosePos = scanPos;
+        lastCloseConsumed = 1 + nameResult.consumed;
+        const closeToken = ctx.tokens[scanPos + 1 + nameResult.consumed];
+        if (closeToken?.type === "BLOCK_CLOSE") {
+          lastCloseConsumed++;
+        }
+      }
     }
-    pos += nameResult.consumed;
-    consumed += nameResult.consumed;
+    scanPos++;
+  }
+  if (lastClosePos === -1) {
+    return { success: false };
+  }
+  const endPos = lastClosePos + lastCloseConsumed;
+  while (pos < endPos && pos < ctx.tokens.length) {
+    const t = ctx.tokens[pos];
+    if (!t || t.type === "EOF")
+      break;
+    if (t.type === "NEWLINE") {
+      let peekPos = pos + 1;
+      while (ctx.tokens[peekPos]?.type === "WHITESPACE")
+        peekPos++;
+      if (ctx.tokens[peekPos]?.type === "NEWLINE") {
+        while (ctx.tokens[pos]?.type === "NEWLINE" || ctx.tokens[pos]?.type === "WHITESPACE") {
+          pos++;
+          consumed++;
+        }
+        continue;
+      }
+      elements.push({ element: "line-break" });
+      pos++;
+      consumed++;
+      continue;
+    }
+    elements.push({ element: "text", data: t.value });
+    pos++;
+    consumed++;
+  }
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+  return {
+    success: true,
+    elements: [
+      {
+        element: "container",
+        data: {
+          type: "paragraph",
+          attributes: {},
+          elements
+        }
+      }
+    ],
+    consumed
+  };
+}
+function unwrapEdgeParagraphs(elements) {
+  if (elements.length === 0)
+    return elements;
+  const result = [...elements];
+  if (isParagraphContainer(result[0])) {
+    const inner = result[0].data.elements;
+    result.splice(0, 1, ...inner);
+  }
+  const lastIdx = result.length - 1;
+  if (lastIdx >= 0 && isParagraphContainer(result[lastIdx])) {
+    const inner = result[lastIdx].data.elements;
+    result.splice(lastIdx, 1, ...inner);
+  }
+  return result;
+}
+function isParagraphContainer(el) {
+  return el !== undefined && el.element === "container" && typeof el.data === "object" && el.data !== null && "type" in el.data && el.data.type === "paragraph";
+}
+
+// packages/parser/src/parser/rules/block/code.ts
+var codeBlockRule = {
+  name: "code",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  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) {
+      return { success: false };
+    }
+    if (nameResult.name !== "code") {
+      return { success: false };
+    }
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
     const attrResult = parseAttributesRaw(ctx, pos);
     pos += attrResult.consumed;
     consumed += attrResult.consumed;
@@ -2810,9 +3077,10 @@ function parseCell(ctx, startPos) {
     return false;
   };
   const bodyCtx = { ...ctx, pos };
-  const bodyResult = parseBlocksUntil(bodyCtx, closeCondition);
+  const bodyResult = parseCellContent(bodyCtx, closeCondition);
   consumed += bodyResult.consumed;
   pos += bodyResult.consumed;
+  const hadParagraphBreaks = bodyResult.hadParagraphBreaks;
   if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
     pos++;
     consumed++;
@@ -2830,7 +3098,7 @@ function parseCell(ctx, startPos) {
       consumed++;
     }
   }
-  const processedElements = bodyResult.elements;
+  const processedElements = hadParagraphBreaks ? bodyResult.elements : unwrapSingleInlineParagraph(bodyResult.elements);
   return {
     cell: {
       header: isHeader,
@@ -2842,6 +3110,170 @@ function parseCell(ctx, startPos) {
     consumed
   };
 }
+function unwrapSingleInlineParagraph(elements) {
+  if (elements.length !== 1) {
+    return elements;
+  }
+  const first = elements[0];
+  if (first?.element !== "container" || typeof first.data !== "object" || first.data === null || !("type" in first.data) || first.data.type !== "paragraph") {
+    return elements;
+  }
+  const paragraphData = first.data;
+  const innerElements = paragraphData.elements ?? [];
+  const hasBlockElement = innerElements.some((el) => isBlockElement(el));
+  if (hasBlockElement) {
+    return elements;
+  }
+  return innerElements;
+}
+function isBlockElement(el) {
+  const blockTypes = ["table", "div", "blockquote", "code", "list", "iframe", "image-block"];
+  if (blockTypes.includes(el.element)) {
+    return true;
+  }
+  if (el.element === "container" && typeof el.data === "object" && el.data !== null) {
+    const data = el.data;
+    if (data.type === "paragraph" || data.type === "div" || data.type === "blockquote") {
+      return true;
+    }
+  }
+  return false;
+}
+function parseCellContent(ctx, closeCondition) {
+  const elements = [];
+  let consumed = 0;
+  let pos = ctx.pos;
+  let currentSegment = [];
+  let hasMultipleParts = false;
+  let hasBlockElement = false;
+  let hadParagraphBreaks = false;
+  const flushSegment = (wrapInParagraph) => {
+    if (currentSegment.length === 0)
+      return;
+    while (currentSegment.length > 0) {
+      const last = currentSegment[currentSegment.length - 1];
+      if (last?.element === "text" && typeof last.data === "string" && last.data.trim() === "") {
+        currentSegment.pop();
+      } else if (last?.element === "line-break") {
+        currentSegment.pop();
+      } else {
+        break;
+      }
+    }
+    while (currentSegment.length > 0) {
+      const first = currentSegment[0];
+      if (first?.element === "text" && typeof first.data === "string" && first.data.trim() === "") {
+        currentSegment.shift();
+      } else {
+        break;
+      }
+    }
+    if (currentSegment.length === 0)
+      return;
+    if (wrapInParagraph) {
+      elements.push({
+        element: "container",
+        data: {
+          type: "paragraph",
+          attributes: {},
+          elements: [...currentSegment]
+        }
+      });
+    } else {
+      elements.push(...currentSegment);
+    }
+    currentSegment = [];
+  };
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+    const checkCtx = { ...ctx, pos };
+    if (closeCondition(checkCtx)) {
+      break;
+    }
+    if (token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      if (ctx.tokens[pos]?.type === "NEWLINE") {
+        while (ctx.tokens[pos]?.type === "NEWLINE") {
+          pos++;
+          consumed++;
+        }
+        flushSegment(true);
+        hasMultipleParts = true;
+        hadParagraphBreaks = true;
+        while (ctx.tokens[pos]?.type === "WHITESPACE") {
+          pos++;
+          consumed++;
+        }
+        continue;
+      }
+      const nextToken = ctx.tokens[pos];
+      if (!nextToken || nextToken.type === "BLOCK_END_OPEN" || nextToken.type === "EOF") {
+        continue;
+      }
+      if (nextToken.type === "BLOCK_OPEN") {
+        flushSegment(true);
+        hasMultipleParts = true;
+        continue;
+      }
+      if (currentSegment.length === 0 && elements.length === 0) {
+        continue;
+      }
+      currentSegment.push({ element: "line-break" });
+      continue;
+    }
+    if (token.type === "WHITESPACE" && token.lineStart) {
+      pos++;
+      consumed++;
+      continue;
+    }
+    let matched = false;
+    const blockCtx = { ...ctx, pos };
+    for (const rule of ctx.blockRules) {
+      if (canApplyBlockRule(rule, token)) {
+        const result = rule.parse(blockCtx);
+        if (result.success) {
+          if (currentSegment.length > 0) {
+            flushSegment(true);
+            hasMultipleParts = true;
+          }
+          elements.push(...result.elements);
+          hasBlockElement = true;
+          hasMultipleParts = true;
+          consumed += result.consumed;
+          pos += result.consumed;
+          matched = true;
+          break;
+        }
+      }
+    }
+    if (matched)
+      continue;
+    const inlineCtx = { ...ctx, pos };
+    for (const rule of ctx.inlineRules) {
+      if (canApplyInlineRule(rule, token)) {
+        const result = rule.parse(inlineCtx);
+        if (result.success) {
+          currentSegment.push(...result.elements);
+          consumed += result.consumed;
+          pos += result.consumed;
+          matched = true;
+          break;
+        }
+      }
+    }
+    if (!matched) {
+      currentSegment.push({ element: "text", data: token.value });
+      consumed++;
+      pos++;
+    }
+  }
+  flushSegment(hasMultipleParts || hasBlockElement);
+  return { elements, consumed, hadParagraphBreaks };
+}
 
 // packages/parser/src/parser/rules/block/module/rate/index.ts
 var rateModuleRule = {
@@ -3256,6 +3688,10 @@ var footnoteBlockRule = {
     }
     pos++;
     consumed++;
+    if (ctx.footnoteBlockParsed) {
+      return { success: false };
+    }
+    ctx.footnoteBlockParsed = true;
     const title = attrs.title !== undefined ? attrs.title : null;
     const hide = attrs.hide === "true" || attrs.hide === "yes";
     return {
@@ -3487,6 +3923,12 @@ var alignRule = {
   name: "align",
   startTokens: ["BLOCK_OPEN"],
   requiresLineStart: true,
+  preservesPrecedingLineBreak: true,
+  isStartPattern(ctx, pos) {
+    if (ctx.tokens[pos]?.type !== "BLOCK_OPEN")
+      return false;
+    return parseAlignOpen(ctx, pos + 1) !== null;
+  },
   parse(ctx) {
     const openToken = currentToken(ctx);
     if (openToken.type !== "BLOCK_OPEN") {
@@ -3912,7 +4354,11 @@ var mathBlockRule = {
           break;
         }
       }
-      latexSource += token.value;
+      if (token.type === "BACKSLASH_BREAK") {
+        latexSource += "\\\n";
+      } else {
+        latexSource += token.value;
+      }
       pos++;
       consumed++;
     }
@@ -3971,23 +4417,25 @@ var htmlBlockRule = {
     }
     pos += nameResult.consumed;
     consumed += nameResult.consumed;
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
-    }
+    const attrResult = parseAttributesRaw(ctx, pos);
+    pos += attrResult.consumed;
+    consumed += attrResult.consumed;
+    const style = attrResult.attrs.style;
     if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
       return { success: false };
     }
     pos++;
     consumed++;
     let contents = "";
+    let foundClose = false;
     while (pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
-      if (!token)
+      if (!token || token.type === "EOF")
         break;
       if (token.type === "BLOCK_END_OPEN") {
         const closeNameResult = parseBlockName(ctx, pos + 1);
         if (closeNameResult?.name.toLowerCase() === "html") {
+          foundClose = true;
           break;
         }
       }
@@ -3995,6 +4443,9 @@ var htmlBlockRule = {
       pos++;
       consumed++;
     }
+    if (!foundClose) {
+      return { success: false };
+    }
     if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
       pos++;
       consumed++;
@@ -4020,7 +4471,8 @@ var htmlBlockRule = {
         {
           element: "html",
           data: {
-            contents
+            contents,
+            ...style && { style }
           }
         }
       ],
@@ -4029,9 +4481,9 @@ var htmlBlockRule = {
   }
 };
 
-// packages/parser/src/parser/rules/block/iframe.ts
-var iframeRule = {
-  name: "iframe",
+// packages/parser/src/parser/rules/block/embed-block.ts
+var embedBlockRule = {
+  name: "embed-block",
   startTokens: ["BLOCK_OPEN"],
   requiresLineStart: false,
   parse(ctx) {
@@ -4042,7 +4494,11 @@ var iframeRule = {
     let pos = ctx.pos + 1;
     let consumed = 1;
     const nameResult = parseBlockName(ctx, pos);
-    if (!nameResult || nameResult.name.toLowerCase() !== "iframe") {
+    if (!nameResult) {
+      return { success: false };
+    }
+    const blockName = nameResult.name.toLowerCase();
+    if (blockName !== "embed" && blockName !== "embedvideo" && blockName !== "embedaudio") {
       return { success: false };
     }
     pos += nameResult.consumed;
@@ -4051,50 +4507,156 @@ var iframeRule = {
       pos++;
       consumed++;
     }
-    let url = "";
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+    let contents = "";
+    let foundClose = false;
     while (pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
       if (!token)
         break;
-      if (token.type === "BLOCK_CLOSE" || token.type === "WHITESPACE" || token.type === "NEWLINE") {
-        break;
+      if (token.type === "BLOCK_END_OPEN") {
+        const closeNameResult = parseBlockName(ctx, pos + 1);
+        if (closeNameResult) {
+          const closeName = closeNameResult.name.toLowerCase();
+          if (closeName === "embed" || closeName === "embedvideo" || closeName === "embedaudio") {
+            foundClose = true;
+            break;
+          }
+        }
       }
-      url += token.value;
+      contents += token.value;
       pos++;
       consumed++;
     }
-    if (!url) {
+    if (!foundClose) {
       return { success: false };
     }
-    const attributes = {};
-    while (pos < ctx.tokens.length) {
-      const token = ctx.tokens[pos];
-      if (!token || token.type === "BLOCK_CLOSE")
-        break;
-      if (token.type === "NEWLINE") {
-        break;
+    if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
+      pos++;
+      consumed++;
+      const closeNameResult = parseBlockName(ctx, pos);
+      if (closeNameResult) {
+        pos += closeNameResult.consumed;
+        consumed += closeNameResult.consumed;
       }
-      if (token.type === "WHITESPACE") {
+      if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
         pos++;
         consumed++;
-        continue;
       }
-      if (token.type === "IDENTIFIER" || token.type === "TEXT") {
-        const key = token.value;
+      if (ctx.tokens[pos]?.type === "NEWLINE") {
         pos++;
         consumed++;
-        while (ctx.tokens[pos]?.type === "WHITESPACE") {
-          pos++;
-          consumed++;
-        }
-        if (ctx.tokens[pos]?.type === "EQUALS") {
-          pos++;
-          consumed++;
-          while (ctx.tokens[pos]?.type === "WHITESPACE") {
-            pos++;
-            consumed++;
+      }
+    }
+    contents = contents.trim();
+    return {
+      success: true,
+      elements: [
+        {
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {},
+            elements: [
+              {
+                element: "embed-block",
+                data: {
+                  contents
+                }
+              }
+            ]
           }
-          let value = "";
+        }
+      ],
+      consumed
+    };
+  }
+};
+
+// packages/parser/src/parser/rules/block/iframe.ts
+var ALLOWED_IFRAME_ATTRS = new Set(["width", "height", "style", "scrolling", "frameborder"]);
+function normalizeUrl(url) {
+  return url.replace(/[\s\u0000-\u001f\u007f-\u009f]/g, "").toLowerCase();
+}
+function isDangerousUrl(normalizedUrl) {
+  return /^(javascript|data|vbscript):/i.test(normalizedUrl);
+}
+var iframeRule = {
+  name: "iframe",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  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() !== "iframe") {
+      return { success: false };
+    }
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+    let url = "";
+    while (pos < ctx.tokens.length) {
+      const token = ctx.tokens[pos];
+      if (!token)
+        break;
+      if (token.type === "BLOCK_CLOSE" || token.type === "WHITESPACE" || token.type === "NEWLINE") {
+        break;
+      }
+      url += token.value;
+      pos++;
+      consumed++;
+    }
+    if (!url) {
+      return { success: false };
+    }
+    const normalizedUrl = normalizeUrl(url);
+    if (isDangerousUrl(normalizedUrl)) {
+      return { success: false };
+    }
+    if (!/^https?:\/\//i.test(normalizedUrl)) {
+      return { success: false };
+    }
+    const attributes = {};
+    while (pos < ctx.tokens.length) {
+      const token = ctx.tokens[pos];
+      if (!token || token.type === "BLOCK_CLOSE")
+        break;
+      if (token.type === "NEWLINE") {
+        break;
+      }
+      if (token.type === "WHITESPACE") {
+        pos++;
+        consumed++;
+        continue;
+      }
+      if (token.type === "IDENTIFIER" || token.type === "TEXT") {
+        const key = token.value;
+        pos++;
+        consumed++;
+        while (ctx.tokens[pos]?.type === "WHITESPACE") {
+          pos++;
+          consumed++;
+        }
+        if (ctx.tokens[pos]?.type === "EQUALS") {
+          pos++;
+          consumed++;
+          while (ctx.tokens[pos]?.type === "WHITESPACE") {
+            pos++;
+            consumed++;
+          }
+          let value = "";
           const valueToken = ctx.tokens[pos];
           if (valueToken?.type === "QUOTED_STRING") {
             value = valueToken.value.slice(1, -1);
@@ -4111,7 +4673,9 @@ var iframeRule = {
               consumed++;
             }
           }
-          attributes[key] = value;
+          if (ALLOWED_IFRAME_ATTRS.has(key.toLowerCase())) {
+            attributes[key.toLowerCase()] = value;
+          }
         }
       } else {
         pos++;
@@ -4313,6 +4877,300 @@ var tocRule = {
   }
 };
 
+// packages/parser/src/parser/rules/block/orphan-li.ts
+function isLiOpen2(ctx, pos) {
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN")
+    return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult)
+    return null;
+  if (nameResult.name === "li") {
+    return { consumed: 1 + nameResult.consumed };
+  }
+  return null;
+}
+function isLiClose2(ctx, pos) {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN")
+    return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult || nameResult.name !== "li")
+    return null;
+  let consumed = 1 + nameResult.consumed;
+  if (ctx.tokens[pos + consumed]?.type === "BLOCK_CLOSE")
+    consumed++;
+  return { consumed };
+}
+var orphanLiRule = {
+  name: "orphan-li",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  parse(ctx) {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+    const liOpen = isLiOpen2(ctx, ctx.pos);
+    if (!liOpen) {
+      return { success: false };
+    }
+    let pos = ctx.pos + liOpen.consumed;
+    let consumed = liOpen.consumed;
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+    const elements = [];
+    let foundClose = false;
+    elements.push({ element: "text", data: "[[" });
+    elements.push({ element: "text", data: "li" });
+    elements.push({ element: "text", data: "]]" });
+    while (pos < ctx.tokens.length) {
+      const token = ctx.tokens[pos];
+      if (!token || token.type === "EOF")
+        break;
+      const liClose = isLiClose2(ctx, pos);
+      if (liClose) {
+        foundClose = true;
+        elements.push({ element: "text", data: "[[/" });
+        elements.push({ element: "text", data: "li" });
+        elements.push({ element: "text", data: "]]" });
+        consumed += liClose.consumed;
+        pos += liClose.consumed;
+        if (ctx.tokens[pos]?.type === "NEWLINE") {
+          pos++;
+          consumed++;
+        }
+        break;
+      }
+      if (token.type === "NEWLINE") {
+        elements.push({ element: "line-break" });
+        pos++;
+        consumed++;
+        continue;
+      }
+      if (token.type === "WHITESPACE" && token.lineStart) {
+        pos++;
+        consumed++;
+        continue;
+      }
+      elements.push({ element: "text", data: token.value });
+      pos++;
+      consumed++;
+    }
+    if (!foundClose) {
+      return { success: false };
+    }
+    return {
+      success: true,
+      elements,
+      consumed
+    };
+  }
+};
+
+// packages/parser/src/parser/rules/block/bibliography.ts
+function parseBibliographyEntry(ctx, startPos) {
+  let pos = startPos;
+  let consumed = 0;
+  const colonToken = ctx.tokens[pos];
+  if (!colonToken || colonToken.type !== "COLON" || !colonToken.lineStart) {
+    return null;
+  }
+  pos++;
+  consumed++;
+  const whitespaceAfterColon = ctx.tokens[pos];
+  if (!whitespaceAfterColon || whitespaceAfterColon.type !== "WHITESPACE") {
+    return null;
+  }
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+  let label = "";
+  let foundSecondColon = false;
+  const keyNodes = [];
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
+      break;
+    }
+    if (token.type === "COLON") {
+      foundSecondColon = true;
+      pos++;
+      consumed++;
+      break;
+    }
+    label += token.value;
+    keyNodes.push({ element: "text", data: token.value });
+    pos++;
+    consumed++;
+  }
+  if (!foundSecondColon) {
+    return null;
+  }
+  label = label.trim();
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+  const contentNodes = [];
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+    if (token.type === "BLOCK_END_OPEN") {
+      const closeNameResult = parseBlockName(ctx, pos + 1);
+      if (closeNameResult?.name === "bibliography") {
+        break;
+      }
+    }
+    if (token.type === "NEWLINE") {
+      const nextToken = ctx.tokens[pos + 1];
+      if (nextToken?.type === "COLON" && nextToken.lineStart) {
+        pos++;
+        consumed++;
+        break;
+      }
+      if (nextToken?.type === "BLOCK_END_OPEN") {
+        pos++;
+        consumed++;
+        break;
+      }
+      if (nextToken?.type === "NEWLINE" || !nextToken || nextToken.type === "EOF") {
+        pos++;
+        consumed++;
+        break;
+      }
+    }
+    const inlineCtx = { ...ctx, pos };
+    const result = parseInlineUntil(inlineCtx, "NEWLINE");
+    if (result.elements.length > 0) {
+      contentNodes.push(...result.elements);
+      pos += result.consumed;
+      consumed += result.consumed;
+    } else {
+      pos++;
+      consumed++;
+    }
+  }
+  while (keyNodes.length > 0) {
+    const lastNode = keyNodes[keyNodes.length - 1];
+    if (lastNode && lastNode.element === "text" && typeof lastNode.data === "string" && lastNode.data.trim() === "") {
+      keyNodes.pop();
+    } else {
+      break;
+    }
+  }
+  return {
+    entry: {
+      label,
+      key: keyNodes,
+      content: contentNodes
+    },
+    consumed
+  };
+}
+var bibliographyRule = {
+  name: "bibliography",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  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 !== "bibliography") {
+      return { success: false };
+    }
+    pos += nameResult.consumed;
+    consumed += nameResult.consumed;
+    const attrResult = parseAttributes(ctx, pos);
+    pos += attrResult.consumed;
+    consumed += attrResult.consumed;
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+    if (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+    const entries = [];
+    let foundClose = false;
+    while (pos < ctx.tokens.length) {
+      const token = ctx.tokens[pos];
+      if (!token || token.type === "EOF") {
+        break;
+      }
+      if (token.type === "BLOCK_END_OPEN") {
+        const closeNameResult = parseBlockName(ctx, pos + 1);
+        if (closeNameResult?.name === "bibliography") {
+          foundClose = true;
+          pos++;
+          consumed++;
+          pos += closeNameResult.consumed;
+          consumed += closeNameResult.consumed;
+          while (ctx.tokens[pos]?.type === "WHITESPACE") {
+            pos++;
+            consumed++;
+          }
+          if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+            pos++;
+            consumed++;
+          }
+          break;
+        }
+      }
+      if (token.type === "WHITESPACE" || token.type === "NEWLINE") {
+        pos++;
+        consumed++;
+        continue;
+      }
+      if (token.type === "COLON" && token.lineStart) {
+        const result = parseBibliographyEntry(ctx, pos);
+        if (result) {
+          entries.push(result.entry);
+          pos += result.consumed;
+          consumed += result.consumed;
+          continue;
+        }
+      }
+      pos++;
+      consumed++;
+    }
+    if (!foundClose) {
+      return { success: false };
+    }
+    const definitionItems = entries.map((entry) => ({
+      key_string: entry.label,
+      key: entry.key,
+      value: entry.content
+    }));
+    const title = attrResult.attrs.title ?? null;
+    const hide = attrResult.attrs.hide === "true" || attrResult.attrs.hide === "";
+    return {
+      success: true,
+      elements: [
+        {
+          element: "bibliography-block",
+          data: {
+            entries: definitionItems,
+            title: typeof title === "string" ? title : null,
+            hide
+          }
+        }
+      ],
+      consumed
+    };
+  }
+};
+
 // packages/parser/src/parser/rules/block/index.ts
 var blockRules = [
   blockCommentRule,
@@ -4325,6 +5183,7 @@ var blockRules = [
   tableBlockRule,
   listRule,
   blockListRule,
+  orphanLiRule,
   blockquoteRule,
   definitionListRule,
   codeBlockRule,
@@ -4337,8 +5196,10 @@ var blockRules = [
   includeRule,
   mathBlockRule,
   htmlBlockRule,
+  embedBlockRule,
   iframeRule,
   iftagsRule,
+  bibliographyRule,
   divRule
 ];
 // packages/parser/src/parser/rules/inline/bold.ts
@@ -4355,6 +5216,13 @@ var boldRule = {
       };
     }
     const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "BOLD_MARKER");
+    if (result.elements.length === 0) {
+      return {
+        success: true,
+        elements: [],
+        consumed: 1 + result.consumed + 1
+      };
+    }
     return {
       success: true,
       elements: [
@@ -4445,6 +5313,13 @@ var underlineRule = {
         consumed++;
       }
     }
+    if (children.length === 0) {
+      return {
+        success: true,
+        elements: [],
+        consumed
+      };
+    }
     return {
       success: true,
       elements: [
@@ -4525,6 +5400,13 @@ var superscriptRule = {
       };
     }
     const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "SUPER_MARKER");
+    if (result.elements.length === 0) {
+      return {
+        success: true,
+        elements: [],
+        consumed: 1 + result.consumed + 1
+      };
+    }
     return {
       success: true,
       elements: [
@@ -4556,6 +5438,13 @@ var subscriptRule = {
       };
     }
     const result = parseInlineUntil({ ...ctx, pos: ctx.pos + 1 }, "SUB_MARKER");
+    if (result.elements.length === 0) {
+      return {
+        success: true,
+        elements: [],
+        consumed: 1 + result.consumed + 1
+      };
+    }
     return {
       success: true,
       elements: [
@@ -4602,15 +5491,38 @@ var monospaceRule = {
       consumed: 1 + result.consumed + 1
     };
   }
-};
-
-// packages/parser/src/parser/rules/inline/link-triple.ts
+};
+
+// packages/parser/src/parser/rules/inline/link-triple.ts
+function hasClosingLinkMarker(ctx, startPos) {
+  let pos = startPos;
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      return false;
+    }
+    if (token.type === "LINK_CLOSE") {
+      return true;
+    }
+    if (token.type === "NEWLINE") {
+      const next = ctx.tokens[pos + 1];
+      if (next?.type === "NEWLINE") {
+        return false;
+      }
+      if (next?.type === "LINK_CLOSE") {
+        return false;
+      }
+    }
+    pos++;
+  }
+  return false;
+}
 var linkTripleRule = {
   name: "linkTriple",
   startTokens: ["LINK_OPEN"],
   parse(ctx) {
     const startToken = currentToken(ctx);
-    if (!hasClosingMarkerBeforeNewline({ ...ctx, pos: ctx.pos + 1 }, "LINK_CLOSE")) {
+    if (!hasClosingLinkMarker(ctx, ctx.pos + 1)) {
       return {
         success: true,
         elements: [{ element: "text", data: startToken.value }],
@@ -4624,9 +5536,14 @@ var linkTripleRule = {
     let pos = ctx.pos + 1;
     while (pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
-      if (!token || token.type === "LINK_CLOSE" || token.type === "NEWLINE" || token.type === "EOF") {
+      if (!token || token.type === "LINK_CLOSE" || token.type === "EOF") {
         break;
       }
+      if (token.type === "NEWLINE") {
+        consumed++;
+        pos++;
+        continue;
+      }
       if (token.type === "PIPE" && !foundPipe) {
         foundPipe = true;
       } else if (foundPipe) {
@@ -4641,8 +5558,40 @@ var linkTripleRule = {
       consumed++;
     }
     const trimmedTarget = target.trim();
-    const { linkType, link } = determineLinkTypeAndLocation(trimmedTarget);
-    const displayText = foundPipe ? labelText.trim() : trimmedTarget;
+    if (trimmedTarget === "" && foundPipe) {
+      return {
+        success: true,
+        elements: [{ element: "text", data: startToken.value }],
+        consumed: 1
+      };
+    }
+    if (/#{2,}/.test(trimmedTarget)) {
+      return {
+        success: true,
+        elements: [{ element: "text", data: startToken.value }],
+        consumed: 1
+      };
+    }
+    let finalTarget = trimmedTarget;
+    if (trimmedTarget === "*" && foundPipe) {
+      finalTarget = "";
+    }
+    if (trimmedTarget.startsWith("*") && !foundPipe) {
+      finalTarget = trimmedTarget.slice(1);
+    }
+    const { linkType, link } = determineLinkTypeAndLocation(finalTarget);
+    const trimmedLabel = labelText.trim();
+    let displayText;
+    if (foundPipe) {
+      displayText = trimmedLabel || finalTarget;
+    } else {
+      const colonIdx = trimmedTarget.indexOf(":");
+      if (colonIdx !== -1 && !trimmedTarget.startsWith("http")) {
+        displayText = trimmedTarget.slice(colonIdx + 1).trim();
+      } else {
+        displayText = trimmedTarget;
+      }
+    }
     const label = { text: displayText };
     return {
       success: true,
@@ -4662,6 +5611,7 @@ var linkTripleRule = {
     };
   }
 };
+var INTERWIKI_PREFIXES = new Set(["wikipedia", "google", "dictionary", "wikidot"]);
 function determineLinkTypeAndLocation(target) {
   if (target.startsWith("#")) {
     return { linkType: "anchor", link: target };
@@ -4669,8 +5619,12 @@ function determineLinkTypeAndLocation(target) {
   if (target.startsWith("http://") || target.startsWith("https://")) {
     return { linkType: "direct", link: target };
   }
-  if (target.includes(":") && !target.includes("/")) {
-    return { linkType: "interwiki", link: target };
+  const colonIdx = target.indexOf(":");
+  if (colonIdx > 0 && !target.includes("/")) {
+    const prefix = target.slice(0, colonIdx).toLowerCase();
+    if (INTERWIKI_PREFIXES.has(prefix)) {
+      return { linkType: "interwiki", link: target };
+    }
   }
   return { linkType: "page", link: { site: null, page: target } };
 }
@@ -4928,7 +5882,7 @@ var colorRule = {
     }
     const textChildren = contentResult.elements;
     const trimmedColor = colorSpec.trim();
-    if (textChildren.length === 0) {
+    if (trimmedColor === "" || textChildren.length === 0) {
       return { success: false };
     }
     return {
@@ -4978,7 +5932,36 @@ var newlineLineBreakRule = {
       lookAhead++;
     }
     const nextMeaningfulToken = ctx.tokens[ctx.pos + lookAhead];
-    if (!nextMeaningfulToken || nextMeaningfulToken.type === "EOF" || nextMeaningfulToken.type === "NEWLINE" || isBlockStartToken(nextMeaningfulToken.type)) {
+    let isValidBlock = isBlockStartToken(nextMeaningfulToken?.type);
+    if (isValidBlock && (nextMeaningfulToken?.type === "LIST_BULLET" || nextMeaningfulToken?.type === "LIST_NUMBER")) {
+      if (!nextMeaningfulToken.lineStart) {
+        isValidBlock = false;
+      }
+    }
+    if (isValidBlock && nextMeaningfulToken?.type === "HEADING_MARKER") {
+      const markerLen = nextMeaningfulToken.value.length;
+      const afterPos = ctx.pos + lookAhead + 1;
+      const afterMarker = ctx.tokens[afterPos];
+      if (markerLen > 6) {
+        isValidBlock = false;
+      } else if (afterMarker?.type === "STAR") {
+        if (ctx.tokens[afterPos + 1]?.type !== "WHITESPACE")
+          isValidBlock = false;
+      } else if (afterMarker?.type !== "WHITESPACE") {
+        isValidBlock = false;
+      }
+    }
+    let hasBackslashBreak = false;
+    {
+      let ahead = 1;
+      while (ctx.tokens[ctx.pos + ahead]?.type === "WHITESPACE") {
+        ahead++;
+      }
+      if (ctx.tokens[ctx.pos + ahead]?.type === "BACKSLASH_BREAK") {
+        hasBackslashBreak = true;
+      }
+    }
+    if (!nextMeaningfulToken || nextMeaningfulToken.type === "EOF" || nextMeaningfulToken.type === "NEWLINE" || isValidBlock || hasBackslashBreak) {
       return {
         success: true,
         elements: [],
@@ -4992,6 +5975,52 @@ var newlineLineBreakRule = {
     };
   }
 };
+var backslashLineBreakRule = {
+  name: "backslashLineBreak",
+  startTokens: ["WHITESPACE", "BACKSLASH_BREAK"],
+  parse(ctx) {
+    const currentTok = ctx.tokens[ctx.pos];
+    if (!currentTok) {
+      return { success: false };
+    }
+    if (currentTok.type === "WHITESPACE") {
+      const nextTok = ctx.tokens[ctx.pos + 1];
+      if (nextTok?.type === "BACKSLASH_BREAK") {
+        const afterBreak = ctx.tokens[ctx.pos + 2];
+        const afterAfter = ctx.tokens[ctx.pos + 3];
+        const afterAfterAfter = ctx.tokens[ctx.pos + 4];
+        const isFollowedByUnderscoreBreak = afterBreak?.type === "WHITESPACE" && afterAfter?.type === "UNDERSCORE" && (afterAfterAfter?.type === "NEWLINE" || afterAfterAfter?.type === "EOF");
+        if (isFollowedByUnderscoreBreak) {
+          const lb2 = { element: "line-break" };
+          lb2._preservedTrailingBreak = true;
+          return {
+            success: true,
+            elements: [lb2],
+            consumed: 2
+          };
+        }
+        const lb = { element: "line-break" };
+        lb._preservedTrailingBreak = true;
+        return {
+          success: true,
+          elements: [lb, { element: "text", data: " " }],
+          consumed: 2
+        };
+      }
+      return { success: false };
+    }
+    if (currentTok.type === "BACKSLASH_BREAK") {
+      const lb = { element: "line-break" };
+      lb._preservedTrailingBreak = true;
+      return {
+        success: true,
+        elements: [lb],
+        consumed: 1
+      };
+    }
+    return { success: false };
+  }
+};
 var underscoreLineBreakRule = {
   name: "underscoreLineBreak",
   startTokens: ["WHITESPACE", "UNDERSCORE"],
@@ -5004,9 +6033,11 @@ var underscoreLineBreakRule = {
       const nextTok = ctx.tokens[ctx.pos + 1];
       const afterTok = ctx.tokens[ctx.pos + 2];
       if (nextTok?.type === "UNDERSCORE" && afterTok && (afterTok.type === "NEWLINE" || afterTok.type === "EOF")) {
+        const lb = { element: "line-break" };
+        lb._preservedTrailingBreak = true;
         return {
           success: true,
-          elements: [{ element: "line-break" }],
+          elements: [lb],
           consumed: 3
         };
       }
@@ -5014,9 +6045,11 @@ var underscoreLineBreakRule = {
     if (currentTok.type === "UNDERSCORE" && currentTok.lineStart) {
       const nextTok = ctx.tokens[ctx.pos + 1];
       if (nextTok && (nextTok.type === "NEWLINE" || nextTok.type === "EOF")) {
+        const lb = { element: "line-break" };
+        lb._preservedTrailingBreak = true;
         return {
           success: true,
-          elements: [{ element: "line-break" }],
+          elements: [lb],
           consumed: 2
         };
       }
@@ -5072,29 +6105,25 @@ function parseDoubleAtRaw(ctx) {
   const startToken = currentToken(ctx);
   let pos = ctx.pos + 1;
   const next1 = ctx.tokens[pos];
-  const next2 = ctx.tokens[pos + 1];
-  if (next1?.type === "RAW_OPEN" && next2?.type === "RAW_OPEN") {
-    return {
-      success: true,
-      elements: [{ element: "raw", data: "@@" }],
-      consumed: 3
-    };
-  }
-  if (next1?.type === "RAW_OPEN" && next2?.type === "AT") {
-    return {
-      success: true,
-      elements: [{ element: "raw", data: "@" }],
-      consumed: 3
-    };
-  }
   if (next1?.type === "RAW_OPEN") {
     return {
       success: true,
-      elements: [{ element: "raw", data: "" }],
+      elements: [],
       consumed: 2
     };
   }
   if (!hasClosingMarkerBeforeNewline({ ...ctx, pos }, "RAW_OPEN")) {
+    const nextToken = ctx.tokens[pos];
+    if (nextToken?.type === "NEWLINE") {
+      const afterNewline = ctx.tokens[pos + 1];
+      if (afterNewline?.type === "RAW_OPEN") {
+        return {
+          success: true,
+          elements: [],
+          consumed: 3
+        };
+      }
+    }
     return {
       success: true,
       elements: [{ element: "text", data: startToken.value }],
@@ -5103,17 +6132,46 @@ function parseDoubleAtRaw(ctx) {
   }
   let value = "";
   let consumed = 1;
+  let hasBlockOpen = false;
+  let hasBlockClose = false;
   while (pos < ctx.tokens.length) {
     const token = ctx.tokens[pos];
     if (!token || token.type === "RAW_OPEN" || token.type === "NEWLINE" || token.type === "EOF") {
       break;
     }
+    if (token.type === "RAW_BLOCK_CLOSE") {
+      const nextToken = ctx.tokens[pos + 1];
+      if (nextToken?.type === "RAW_OPEN") {
+        value += ">";
+        consumed += 2;
+        return {
+          success: true,
+          elements: [
+            { element: "raw", data: value },
+            { element: "text", data: "@" }
+          ],
+          consumed
+        };
+      }
+      hasBlockClose = true;
+    }
+    if (token.type === "RAW_BLOCK_OPEN") {
+      hasBlockOpen = true;
+    }
     value += token.value;
     consumed++;
     pos++;
   }
   if (ctx.tokens[pos]?.type === "RAW_OPEN") {
     consumed++;
+    pos++;
+  }
+  if (hasBlockOpen && hasBlockClose) {
+    return {
+      success: true,
+      elements: [],
+      consumed
+    };
   }
   return {
     success: true,
@@ -5125,6 +6183,17 @@ function parseAngleRaw(ctx) {
   const startToken = currentToken(ctx);
   let pos = ctx.pos + 1;
   if (!hasClosingMarkerBeforeNewline({ ...ctx, pos }, "RAW_BLOCK_CLOSE")) {
+    const nextToken = ctx.tokens[pos];
+    if (nextToken?.type === "NEWLINE") {
+      const afterNewline = ctx.tokens[pos + 1];
+      if (afterNewline?.type === "RAW_BLOCK_CLOSE") {
+        return {
+          success: true,
+          elements: [{ element: "text", data: startToken.value }],
+          consumed: 3
+        };
+      }
+    }
     return {
       success: true,
       elements: [{ element: "text", data: startToken.value }],
@@ -5406,6 +6475,12 @@ var closeSpanRule = {
 };
 
 // packages/parser/src/parser/rules/inline/size.ts
+var VALID_SIZE_UNITS = ["px", "em", "rem", "ex", "%", "cm", "mm", "in", "pc"];
+function isValidSizeValue(size) {
+  const unitPattern = VALID_SIZE_UNITS.join("|");
+  const match = size.match(new RegExp(`^(\\d+(?:\\.\\d+)?)(${unitPattern})$`, "i"));
+  return match !== null;
+}
 function parseSizeValue(ctx, startPos) {
   let pos = startPos;
   let consumed = 0;
@@ -5429,7 +6504,11 @@ function parseSizeValue(ctx, startPos) {
   if (parts.length === 0) {
     return null;
   }
-  return { size: parts.join(""), consumed };
+  const size = parts.join("");
+  if (!isValidSizeValue(size)) {
+    return null;
+  }
+  return { size, consumed };
 }
 var sizeRule = {
   name: "size",
@@ -5541,7 +6620,8 @@ var footnoteRule = {
     }
     pos++;
     consumed++;
-    const children = [];
+    const paragraphs = [[]];
+    let currentParagraph = 0;
     while (pos < ctx.tokens.length) {
       const token = ctx.tokens[pos];
       if (!token || token.type === "EOF") {
@@ -5566,23 +6646,58 @@ var footnoteRule = {
         }
       }
       if (token.type === "NEWLINE") {
-        children.push({ element: "line-break" });
         pos++;
         consumed++;
+        if (ctx.tokens[pos]?.type === "NEWLINE") {
+          while (ctx.tokens[pos]?.type === "NEWLINE") {
+            pos++;
+            consumed++;
+          }
+          currentParagraph++;
+          paragraphs[currentParagraph] = [];
+        } else {
+          paragraphs[currentParagraph].push({ element: "line-break" });
+        }
         continue;
       }
       const inlineCtx = { ...ctx, pos };
       const inlineResult = parseInlineUntil(inlineCtx, "BLOCK_END_OPEN");
       if (inlineResult.elements.length > 0) {
-        children.push(...inlineResult.elements);
+        paragraphs[currentParagraph].push(...inlineResult.elements);
         pos += inlineResult.consumed;
         consumed += inlineResult.consumed;
       } else {
-        children.push({ element: "text", data: token.value });
+        paragraphs[currentParagraph].push({ element: "text", data: token.value });
         pos++;
         consumed++;
       }
     }
+    const children = [];
+    for (let i = 0;i < paragraphs.length; i++) {
+      const para = paragraphs[i];
+      if (para.length === 0)
+        continue;
+      while (para.length > 0 && para[0]?.element === "line-break") {
+        para.shift();
+      }
+      while (para.length > 0 && para[para.length - 1]?.element === "line-break") {
+        para.pop();
+      }
+      if (para.length === 0)
+        continue;
+      if (i === 0) {
+        children.push(...para);
+      } else {
+        children.push({
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {},
+            elements: para
+          }
+        });
+      }
+    }
     ctx.footnotes.push(children);
     return {
       success: true,
@@ -5636,6 +6751,10 @@ function parseImageBlockName(ctx, startPos) {
       prefix = "f>";
       pos += 2;
       consumed += 2;
+    } else if (nextToken?.type === "EQUALS") {
+      prefix = "f=";
+      pos += 2;
+      consumed += 2;
     }
   }
   const nameToken = ctx.tokens[pos];
@@ -5658,6 +6777,15 @@ function parseImageSource(src) {
     const file = rest.substring(lastSlash + 1);
     return { type: "file3", data: { site, page, file } };
   }
+  const slashes = src.split("/").length - 1;
+  if (slashes >= 2) {
+    const firstSlash = src.indexOf("/");
+    const lastSlash = src.lastIndexOf("/");
+    const site = src.substring(0, firstSlash);
+    const page = src.substring(firstSlash + 1, lastSlash);
+    const file = src.substring(lastSlash + 1);
+    return { type: "file3", data: { site, page, file } };
+  }
   if (slashIdx > 0) {
     const page = src.substring(0, slashIdx);
     const file = src.substring(slashIdx + 1);
@@ -5680,6 +6808,9 @@ function parseAlignment(blockName) {
   } else if (blockName === "f>image") {
     align = "right";
     float = true;
+  } else if (blockName === "f=image") {
+    align = "center";
+    float = true;
   } else if (blockName === "image") {
     return null;
   }
@@ -5700,7 +6831,7 @@ var imageRule = {
       return { success: false };
     }
     const blockName = nameResult.name;
-    const imageNames = ["image", "=image", "<image", ">image", "f<image", "f>image"];
+    const imageNames = ["image", "=image", "<image", ">image", "f<image", "f>image", "f=image"];
     if (!imageNames.includes(blockName)) {
       return { success: false };
     }
@@ -5789,9 +6920,8 @@ var userRule = {
     }
     let pos = ctx.pos + 1;
     let consumed = 1;
-    while (ctx.tokens[pos]?.type === "WHITESPACE") {
-      pos++;
-      consumed++;
+    if (ctx.tokens[pos]?.type === "WHITESPACE") {
+      return { success: false };
     }
     let showAvatar = false;
     if (ctx.tokens[pos]?.type === "STAR") {
@@ -6015,6 +7145,10 @@ var anchorRule = {
             consumed++;
           }
           foundClose = true;
+          while (paragraphStrip && ctx.tokens[pos]?.type === "NEWLINE") {
+            pos++;
+            consumed++;
+          }
           break;
         }
       }
@@ -6515,6 +7649,79 @@ var ifExprRule = {
   }
 };
 
+// packages/parser/src/parser/rules/inline/bibcite.ts
+var bibciteRule = {
+  name: "bibcite",
+  startTokens: ["TEXT"],
+  parse(ctx) {
+    const token = currentToken(ctx);
+    if (token.type !== "TEXT" || token.value !== "(") {
+      return { success: false };
+    }
+    const nextToken = ctx.tokens[ctx.pos + 1];
+    if (!nextToken || nextToken.type !== "TEXT" || nextToken.value !== "(") {
+      return { success: false };
+    }
+    let pos = ctx.pos + 2;
+    let consumed = 2;
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+    const nameToken = ctx.tokens[pos];
+    if (!nameToken || nameToken.type !== "IDENTIFIER" || nameToken.value.toLowerCase() !== "bibcite") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+    const labelToken = ctx.tokens[pos];
+    if (!labelToken || labelToken.type !== "IDENTIFIER" && labelToken.type !== "TEXT") {
+      return { success: false };
+    }
+    let label = "";
+    while (pos < ctx.tokens.length) {
+      const t = ctx.tokens[pos];
+      if (!t)
+        break;
+      if (t.type === "TEXT" && t.value === ")") {
+        const nextT = ctx.tokens[pos + 1];
+        if (nextT?.type === "TEXT" && nextT.value === ")") {
+          consumed += 2;
+          break;
+        }
+      }
+      if (t.type === "NEWLINE" || t.type === "EOF") {
+        return { success: false };
+      }
+      label += t.value;
+      pos++;
+      consumed++;
+    }
+    label = label.trim();
+    if (!label) {
+      return { success: false };
+    }
+    ctx.bibcites.push(label);
+    return {
+      success: true,
+      elements: [
+        {
+          element: "bibliography-cite",
+          data: {
+            label,
+            brackets: false
+          }
+        }
+      ],
+      consumed
+    };
+  }
+};
+
 // packages/parser/src/parser/rules/inline/text.ts
 var textRule = {
   name: "text",
@@ -6543,6 +7750,7 @@ var inlineRules = [
   linkAnchorRule,
   linkStarRule,
   colorRule,
+  backslashLineBreakRule,
   underscoreLineBreakRule,
   newlineLineBreakRule,
   commentRule,
@@ -6560,6 +7768,7 @@ var inlineRules = [
   anchorRule,
   mathInlineRule,
   equationRefRule,
+  bibciteRule,
   guillemetRule,
   textRule
 ];
@@ -6716,6 +7925,59 @@ function splitParagraphAtBlankLineSpans(para) {
   }
   return result.length > 0 ? result : [para];
 }
+function isEmptyExpr(el) {
+  if (el.element !== "expr")
+    return false;
+  const data = el.data;
+  return data.expression === "";
+}
+function splitParagraphAtEmptyExpr(para) {
+  const data = getContainerData(para);
+  if (!data || data.type !== "paragraph")
+    return [para];
+  const hasEmptyExpr = data.elements.some(isEmptyExpr);
+  if (!hasEmptyExpr)
+    return [para];
+  const result = [];
+  let currentElements = [];
+  for (let i = 0;i < data.elements.length; i++) {
+    const child = data.elements[i];
+    if (!child)
+      continue;
+    if (isEmptyExpr(child)) {
+      if (currentElements.length > 0 && currentElements[currentElements.length - 1]?.element === "line-break") {
+        currentElements.pop();
+      }
+      if (currentElements.length > 0) {
+        result.push({
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {},
+            elements: currentElements
+          }
+        });
+        currentElements = [];
+      }
+      if (i + 1 < data.elements.length && data.elements[i + 1]?.element === "line-break") {
+        i++;
+      }
+    } else {
+      currentElements.push(child);
+    }
+  }
+  if (currentElements.length > 0) {
+    result.push({
+      element: "container",
+      data: {
+        type: "paragraph",
+        attributes: {},
+        elements: currentElements
+      }
+    });
+  }
+  return result.length > 0 ? result : [];
+}
 function mergeSpanStripParagraphs(children) {
   const expandedChildren = [];
   for (const child of children) {
@@ -6723,6 +7985,8 @@ function mergeSpanStripParagraphs(children) {
       const data = getContainerData(child);
       if (data && data.elements.some(isSplitSpan)) {
         expandedChildren.push(...splitParagraphAtBlankLineSpans(child));
+      } else if (data && data.elements.some(isEmptyExpr)) {
+        expandedChildren.push(...splitParagraphAtEmptyExpr(child));
       } else {
         expandedChildren.push(child);
       }
@@ -6740,7 +8004,8 @@ function mergeSpanStripParagraphs(children) {
       i++;
       continue;
     }
-    if (!hasParagraphStripSpan(node)) {
+    const thisHasSpanStrip = hasParagraphStripSpan(node);
+    if (!thisHasSpanStrip) {
       result.push(node);
       i++;
       continue;
@@ -6754,17 +8019,18 @@ function mergeSpanStripParagraphs(children) {
     const mergedChildren = [...paraData.elements];
     i++;
     while (i < expandedChildren.length) {
-      const nextNode = expandedChildren[i];
-      if (!nextNode || !isContainer(nextNode, "paragraph")) {
+      const nextPara = expandedChildren[i];
+      if (!nextPara || !isContainer(nextPara, "paragraph")) {
         break;
       }
-      const nextParaData = getContainerData(nextNode);
+      const nextParaData = getContainerData(nextPara);
       if (!nextParaData) {
         break;
       }
+      const hasSpanStrip = hasParagraphStripSpan(nextPara);
       mergedChildren.push(...nextParaData.elements);
       i++;
-      if (!hasParagraphStripSpan(nextNode)) {
+      if (!hasSpanStrip) {
         const peekNext = expandedChildren[i];
         if (!peekNext || !isContainer(peekNext, "paragraph") || !hasParagraphStripSpan(peekNext)) {
           break;
@@ -6773,16 +8039,22 @@ function mergeSpanStripParagraphs(children) {
     }
     const escapedSpans = extractEscapedSpans(mergedChildren);
     removeLineBreaksAroundSpanStrip(mergedChildren);
-    if (mergedChildren.length > 0) {
-      const mergedPara = {
-        element: "container",
-        data: {
-          type: "paragraph",
-          attributes: {},
-          elements: mergedChildren
-        }
-      };
-      result.push(mergedPara);
+    if (escapedSpans.length > 0) {
+      if (mergedChildren.length > 0) {
+        const para = {
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {},
+            elements: mergedChildren
+          }
+        };
+        result.push(para);
+      }
+    } else {
+      for (const child of mergedChildren) {
+        result.push(child);
+      }
     }
     for (const span of escapedSpans) {
       result.push(span);
@@ -6823,6 +8095,9 @@ function removeEmptySpansAndAdjacentWhitespace(elements) {
   return result;
 }
 function cleanElement(el) {
+  if (el.element === "line-break") {
+    return { element: "line-break" };
+  }
   if (el.element === "container") {
     const data = el.data;
     const cleanedData = {
@@ -6853,6 +8128,42 @@ function cleanElement(el) {
       }
     };
   }
+  if (el.element === "list") {
+    const data = el.data;
+    return {
+      element: "list",
+      data: {
+        ...data,
+        items: data.items.map((item) => {
+          if (item["item-type"] === "elements") {
+            return {
+              ...item,
+              elements: cleanInternalFlags(item.elements)
+            };
+          } else if (item["item-type"] === "sub-list") {
+            const cleanedList = cleanElement({ element: "list", data: item.data });
+            return {
+              "item-type": "sub-list",
+              element: "list",
+              data: "data" in cleanedList ? cleanedList.data : item.data
+            };
+          }
+          return item;
+        })
+      }
+    };
+  }
+  if (el.element === "definition-list") {
+    const items = el.data;
+    return {
+      element: "definition-list",
+      data: items.map((item) => ({
+        ...item,
+        key: cleanInternalFlags(item.key),
+        value: cleanInternalFlags(item.value)
+      }))
+    };
+  }
   return el;
 }
 // packages/parser/src/parser/toc.ts
@@ -6929,6 +8240,8 @@ class Parser {
       tocEntries: [],
       codeBlocks: [],
       htmlBlocks: [],
+      footnoteBlockParsed: false,
+      bibcites: [],
       blockRules,
       blockFallbackRule: paragraphRule,
       inlineRules