@wdprlib/parser 5.3.0 → 6.0.0

package/src/parser/rules/inline/footnote/content.ts

@@ -1,54 +1,42 @@
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
-import { parseFootnoteChild } from "./child";
+import { parseBlocksUntil } from "../../block/parsing/content";
 import { tryConsumeFootnoteClose } from "./close";
-import { consumeFootnoteNewline } from "./newline";
+import { findFootnoteEnd } from "./boundary";
 
 export interface FootnoteContentResult {
-  paragraphs: Element[][];
+  elements: Element[];
   consumed: number;
   foundClose: boolean;
+  leadingParagraphBreak: boolean;
 }
 
 export function parseFootnoteContent(ctx: ParseContext, startPos: number): FootnoteContentResult {
-  const paragraphs: Element[][] = [[]];
-  let currentParagraph = 0;
-  let pos = startPos;
-  let consumed = 0;
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token || token.type === "EOF") {
-      break;
-    }
-
-    const closeResult = tryConsumeFootnoteClose(ctx, pos);
-    if (closeResult) {
-      return {
-        paragraphs,
-        consumed: consumed + closeResult.consumed,
-        foundClose: true,
-      };
-    }
-
-    if (token.type === "NEWLINE") {
-      const newlineResult = consumeFootnoteNewline(ctx, pos);
-      pos += newlineResult.consumed;
-      consumed += newlineResult.consumed;
-      if (newlineResult.paragraphBreak) {
-        currentParagraph++;
-        paragraphs[currentParagraph] = [];
-      } else {
-        paragraphs[currentParagraph]!.push({ element: "line-break" });
-      }
-      continue;
-    }
-
-    const child = parseFootnoteChild(ctx, pos);
-    paragraphs[currentParagraph]!.push(...child.elements);
-    pos += child.consumed;
-    consumed += child.consumed;
+  const end = findFootnoteEnd(ctx, startPos);
+  let leadingNewlines = 0;
+  for (let pos = startPos; pos < end; pos++) {
+    const type = ctx.tokens[pos]?.type;
+    if (type === "NEWLINE") leadingNewlines++;
+    else if (type !== "WHITESPACE") break;
   }
 
-  return { paragraphs, consumed, foundClose: false };
+  const bodyCtx: ParseContext = {
+    ...ctx,
+    tokens: ctx.tokens.slice(startPos, end),
+    pos: 0,
+    scope: {
+      ...ctx.scope,
+      inlineEnd: undefined,
+      tableFormatting: undefined,
+      blockCloseCondition: undefined,
+    },
+  };
+  const result = parseBlocksUntil(bodyCtx, () => false);
+  const close = tryConsumeFootnoteClose(ctx, end);
+  return {
+    elements: result.elements,
+    consumed: end - startPos + (close?.consumed ?? 0),
+    foundClose: close !== null,
+    leadingParagraphBreak: leadingNewlines >= 2,
+  };
 }

package/src/parser/rules/inline/footnote/elements.ts

@@ -1,38 +1,13 @@
 import type { Element } from "@wdprlib/ast";
 
-export function buildFootnoteChildren(paragraphs: Element[][]): Element[] {
-  const children: Element[] = [];
-
-  for (let i = 0; i < paragraphs.length; i++) {
-    const para = trimLineBreaks(paragraphs[i] ?? []);
-    if (para.length === 0) {
-      continue;
-    }
-
-    if (i === 0) {
-      children.push(...para);
-    } else {
-      children.push({
-        element: "container",
-        data: {
-          type: "paragraph",
-          attributes: {},
-          elements: para,
-        },
-      });
-    }
-  }
-
-  return children;
-}
-
-function trimLineBreaks(elements: Element[]): Element[] {
-  const result = [...elements];
-  while (result.length > 0 && result[0]?.element === "line-break") {
-    result.shift();
-  }
-  while (result.length > 0 && result[result.length - 1]?.element === "line-break") {
-    result.pop();
+/** Wikidot leaves the initial footnote paragraph unwrapped unless a blank line precedes it. */
+export function buildFootnoteChildren(
+  elements: Element[],
+  leadingParagraphBreak: boolean,
+): Element[] {
+  const first = elements[0];
+  if (!leadingParagraphBreak && first?.element === "container" && first.data.type === "paragraph") {
+    return [...first.data.elements, ...elements.slice(1)];
   }
-  return result;
+  return elements;
 }

package/src/parser/rules/inline/footnote/index.ts

@@ -28,7 +28,10 @@ export const footnoteRule: InlineRule = {
 
     const contentResult = parseFootnoteContent(ctx, openResult.bodyStart);
     const consumed = openResult.consumed + contentResult.consumed;
-    const children = buildFootnoteChildren(contentResult.paragraphs);
+    const children = buildFootnoteChildren(
+      contentResult.elements,
+      contentResult.leadingParagraphBreak,
+    );
 
     if (!contentResult.foundClose) {
       ctx.diagnostics.push({

package/src/parser/rules/inline/formatting/close.ts

@@ -1,3 +1,6 @@
+import { emailRegionEnd } from "../email/candidates";
+import { parseButtonSyntax } from "../button/syntax";
+import { parseSocialSyntax } from "../social/syntax";
 import { protectedInlineRegionEnd } from "../raw/end";
 import type { TokenType } from "../../../../lexer";
 import type { ParseContext } from "../../types";
@@ -20,6 +23,15 @@ export function findFormattingClose(
       getParagraphNewlineBoundary(ctx, pos, true).shouldBreak
     )
       return null;
+    const inlineRegionEnd = Math.max(
+      emailRegionEnd(ctx.tokens, pos, end),
+      parseButtonSyntax(ctx, pos, end)?.end ?? pos,
+      parseSocialSyntax(ctx, pos, end)?.end ?? pos,
+    );
+    if (inlineRegionEnd > pos) {
+      pos = inlineRegionEnd - 1;
+      continue;
+    }
     if (token.type === marker && !table?.suppressedClosers.has(pos)) return pos;
     const protectedEnd = protectedInlineRegionEnd(ctx.tokens, pos, end);
     if (protectedEnd > pos) pos = protectedEnd - 1;

package/src/parser/rules/inline/index.ts

@@ -31,6 +31,8 @@ import { linkTripleRule } from "./link-triple";
 import { linkSingleRule } from "./link-single";
 import { linkAnchorRule } from "./link-anchor";
 import { linkStarRule } from "./link-star";
+import { autolinkRule } from "./autolink";
+import { emailRule } from "./email";
 import { colorRule } from "./color";
 import {
   backslashLineBreakRule,
@@ -41,6 +43,9 @@ import { commentRule } from "./comment";
 import { htmlInlineRule } from "./html";
 import { rawRule } from "./raw";
 import { spanRule, closeSpanRule } from "./span";
+import { buttonRule } from "./button";
+import { socialRule } from "./social";
+import { dateRule } from "./date";
 import { sizeRule } from "./size";
 import { footnoteRule } from "./footnote";
 import { imageRule } from "./image";
@@ -65,6 +70,7 @@ export { linkTripleRule } from "./link-triple";
 export { linkSingleRule } from "./link-single";
 export { linkAnchorRule } from "./link-anchor";
 export { linkStarRule } from "./link-star";
+export { autolinkRule } from "./autolink";
 export { colorRule } from "./color";
 export {
   backslashLineBreakRule,
@@ -75,6 +81,9 @@ export { commentRule } from "./comment";
 export { htmlInlineRule } from "./html";
 export { rawRule } from "./raw";
 export { spanRule, closeSpanRule } from "./span";
+export { buttonRule } from "./button";
+export { socialRule } from "./social";
+export { dateRule } from "./date";
 export { sizeRule } from "./size";
 export { footnoteRule } from "./footnote";
 export { imageRule } from "./image";
@@ -112,6 +121,7 @@ export { textRule, fallbackRule } from "./text";
  * separate last-resort handler.
  */
 export const inlineRules: InlineRule[] = [
+  emailRule,
   boldRule,
   italicRule,
   underlineRule,
@@ -123,6 +133,7 @@ export const inlineRules: InlineRule[] = [
   linkSingleRule,
   linkAnchorRule,
   linkStarRule,
+  autolinkRule,
   colorRule,
   backslashLineBreakRule,
   underscoreLineBreakRule,
@@ -132,6 +143,9 @@ export const inlineRules: InlineRule[] = [
   rawRule,
   imageRule,
   embedBlockRule,
+  buttonRule,
+  socialRule,
+  dateRule,
   sizeRule,
   footnoteRule,
   spanRule,

package/src/parser/rules/inline/line-break/newline.ts

@@ -1,3 +1,4 @@
+import { createAutomaticLineBreak } from "../parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { TokenType } from "../../../../lexer";
 import type { InlineRule, ParseContext, RuleResult } from "../../types";
@@ -27,7 +28,7 @@ export const newlineLineBreakRule: InlineRule = {
 
     return {
       success: true,
-      elements: [{ element: "line-break" }],
+      elements: [createAutomaticLineBreak(currentTok)],
       consumed: 1,
     };
   },
@@ -53,6 +54,12 @@ function isValidBlockStartAfterNewline(ctx: ParseContext, tokenPos: number): boo
     return false;
   }
 
+  if (token.type === "LIST_BULLET" || token.type === "LIST_NUMBER") {
+    // リスト構文はマーカー直後の空白が必須（list/line.tsと同じ規則）。
+    // 空白なしの行（例: 行頭の `*http://...`）はリストにならないため<br>を抑制しない
+    return ctx.tokens[tokenPos + 1]?.type === "WHITESPACE";
+  }
+
   if (token.type !== "HEADING_MARKER") {
     return true;
   }

package/src/parser/rules/inline/link-bracket/direct-url.ts

@@ -1,5 +1,13 @@
+import { startsWithUrlScheme } from "../../../../lexer/url-schemes";
+
+/**
+ * Whether `url` is a valid target for a single-bracket link (`[url label]`).
+ *
+ * Matches Text_Wiki's described-URL rule (regexLiberal): a site-relative path
+ * (`/…`) or any recognized URL scheme (http/https/ftp/gopher/news/mms/mailto).
+ * Kept in sync with the autolink rule so bracket-described links and bare
+ * auto-links accept the same schemes.
+ */
 export function isDirectBracketUrl(url: string): boolean {
-  return (
-    url !== "" && (url.startsWith("/") || url.startsWith("http://") || url.startsWith("https://"))
-  );
+  return url !== "" && (url.startsWith("/") || startsWithUrlScheme(url, 0));
 }

package/src/parser/rules/inline/link-bracket/parsed.ts

@@ -4,8 +4,10 @@ import { normalizeAnchor } from "./anchor";
 import { isDirectBracketUrl } from "./direct-url";
 import { collectBracketLinkParts } from "./parts";
 import { parseBracketLinkPrefix } from "./prefix";
+import { isBracketEmail, wikipediaPage } from "./special-target";
 
 export interface ParsedBracketLink {
+  interwiki?: boolean;
   link: string;
   labelText: string;
   target: AnchorTarget | null;
@@ -20,19 +22,22 @@ export function parseSingleBracketLink(ctx: ParseContext): ParsedBracketLink | n
   }
 
   const link = parts.first.trim();
-  if (!isDirectBracketUrl(link)) {
+  const email = isBracketEmail(link);
+  const wikiPage = wikipediaPage(link);
+  if (!email && wikiPage === null && !isDirectBracketUrl(link)) {
     return null;
   }
 
-  const labelText = parts.label.trim();
+  const labelText = parts.label.trim() || wikiPage;
   if (!labelText) {
     return null;
   }
 
   return {
-    link,
+    link: email ? `mailto:${link}` : link,
+    interwiki: wikiPage !== null,
     labelText,
-    target: prefix.target,
+    target: wikiPage !== null ? "new-tab" : prefix.target,
     consumed: 1 + prefix.consumed + parts.consumed,
   };
 }

package/src/parser/rules/inline/link-bracket/parts.ts

@@ -16,49 +16,27 @@ export function collectBracketLinkParts(
   }
 
   let pos = startPos;
-  let consumed = 0;
-  let first = "";
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (
-      !token ||
-      token.type === "WHITESPACE" ||
-      token.type === "BRACKET_CLOSE" ||
-      token.type === "NEWLINE" ||
-      token.type === "EOF"
-    ) {
-      break;
-    }
-    first += token.value;
-    pos++;
-    consumed++;
-  }
-
-  while (ctx.tokens[pos]?.type === "WHITESPACE") {
-    pos++;
-    consumed++;
-  }
-
-  let label = "";
-  while (pos < ctx.tokens.length) {
+  const end = Math.min(ctx.scope.inlineEnd ?? ctx.tokens.length, ctx.tokens.length);
+  const values: string[] = [];
+  while (pos < end) {
     const token = ctx.tokens[pos];
     if (
       !token ||
       token.type === "BRACKET_CLOSE" ||
       token.type === "NEWLINE" ||
       token.type === "EOF"
-    ) {
+    )
       break;
-    }
-    label += token.value;
+    values.push(token.value);
     pos++;
-    consumed++;
   }
-
-  if (ctx.tokens[pos]?.type !== "BRACKET_CLOSE") {
-    return null;
-  }
-
-  return { first, label, consumed: consumed + 1 };
+  if (pos >= end || ctx.tokens[pos]?.type !== "BRACKET_CLOSE") return null;
+  // Compact TEXT tokens can contain both the target and the label separator.
+  const content = values.join("");
+  const separator = content.search(/[ \t]/);
+  return {
+    first: separator === -1 ? content : content.slice(0, separator),
+    label: separator === -1 ? "" : content.slice(separator).trimStart(),
+    consumed: pos - startPos + 1,
+  };
 }

package/src/parser/rules/inline/link-bracket/special-target.ts

@@ -0,0 +1,9 @@
+/** Text_Wiki Email.php described-email grammar; no URI header characters. */
+export function isBracketEmail(target: string): boolean {
+  return /^[_a-z0-9-]+(?:\.[_a-z0-9-]+)*@[a-z0-9-]+(?:\.[a-z0-9-]+)+$/i.test(target);
+}
+
+/** Single-bracket Interwiki.php grammar, restricted to the verified Wikipedia mapping. */
+export function wikipediaPage(target: string): string | null {
+  return /^wikipedia:((?!:)[A-Za-z0-9_/=&~#.:;+-]+)$/.exec(target)?.[1] ?? null;
+}

package/src/parser/rules/inline/link-single.ts

@@ -8,15 +8,17 @@
  * Supported URL formats:
  * - Absolute URLs: `[https://example.com/ Label]`
  * - Relative paths: `[/some-page Label]`
+ * - Email addresses: `[support@example.com Label]`
+ * - Wikipedia links: `[wikipedia:Article]` or `[wikipedia:Article Label]`
  *
  * An optional `*` prefix on the URL opens the link in a new tab:
  * `[*https://example.com/ Opens in new tab]`.
  *
  * Unlike triple-bracket links (`[[[page]]]`), single-bracket links
- * require a full URL (starting with `http://`, `https://`, or `/`).
- * The label text is required.
+ * require an external target or site-relative path.
+ * The label text is required except for Wikipedia links.
  *
- * Produces a `"link"` AST element with `type: "direct"`.
+ * Produces a `"link"` AST element with `type: "direct"` or `"interwiki"`.
  *
  * @module
  */
@@ -33,8 +35,8 @@ import { parseSingleBracketLink } from "./link-bracket/parsed";
  *
  * Fails if:
  * - No closing `]` is found on the same line
- * - The URL does not start with `http://`, `https://`, or `/`
- * - The label text is empty
+ * - The target is not a supported URL, email address, or Wikipedia target
+ * - The label is empty for a non-Wikipedia target
  */
 export const linkSingleRule: InlineRule = {
   name: "linkSingle",
@@ -44,7 +46,7 @@ export const linkSingleRule: InlineRule = {
    * Attempts to parse a single-bracket link at the current position.
    *
    * @param ctx - Parse context with token stream and current position
-   * @returns A successful result with a `"link"` element of type `"direct"`,
+   * @returns A successful result with a `"link"` element of type `"direct"` or `"interwiki"`,
    *          or `{ success: false }`
    */
   parse(ctx: ParseContext): RuleResult<Element> {
@@ -59,7 +61,7 @@ export const linkSingleRule: InlineRule = {
         {
           element: "link",
           data: {
-            type: "direct",
+            type: parsed.interwiki ? "interwiki" : "direct",
             link: parsed.link,
             extra: null,
             label: linkLabel,

package/src/parser/rules/inline/link-triple/index.ts

@@ -36,6 +36,7 @@ export const linkTripleRule: InlineRule = {
     const normalized = normalizeTripleLinkTarget(trimmedTarget);
     const { linkType, link } = determineLinkTypeAndLocation(normalized.target);
     const label = buildTripleLinkLabel({
+      isPage: linkType === "page",
       foundPipe: parts.foundPipe,
       labelText: parts.labelText,
       finalTarget: normalized.target,

package/src/parser/rules/inline/link-triple/label.ts

@@ -1,13 +1,19 @@
 import type { LinkLabel } from "@wdprlib/ast";
 
 export function buildTripleLinkLabel(args: {
+  isPage: boolean;
   foundPipe: boolean;
   labelText: string;
   finalTarget: string;
   originalTarget: string;
 }): LinkLabel {
+  if (args.isPage && args.foundPipe && !args.labelText.trim()) return "page";
   return {
-    text: getTripleLinkDisplayText(args),
+    text: getTripleLinkDisplayText({
+      ...args,
+      originalTarget:
+        args.isPage && !args.foundPipe ? args.originalTarget.split("#")[0]! : args.originalTarget,
+    }),
   };
 }
 

package/src/parser/rules/inline/parsing/automatic-line-break.ts

@@ -0,0 +1,35 @@
+import type { Element } from "@wdprlib/ast";
+import type { Token } from "../../../../lexer";
+import type { ParseContext } from "../../types";
+
+// Suppressed newlines must not cause an earlier, unrelated break to be removed.
+const origins = new WeakMap<Element, Token>();
+
+export function createAutomaticLineBreak(token: Token): Element {
+  const element: Element = { element: "line-break" };
+  origins.set(element, token);
+  return element;
+}
+
+export function precedingSingleNewline(ctx: ParseContext): Token | undefined {
+  let pos = ctx.pos - 1;
+  while (ctx.tokens[pos]?.type === "WHITESPACE") pos--;
+  const newline = ctx.tokens[pos];
+  if (newline?.type !== "NEWLINE") return undefined;
+  pos--;
+  while (ctx.tokens[pos]?.type === "WHITESPACE") pos--;
+  if (ctx.tokens[pos]?.type === "NEWLINE") return undefined;
+  return newline;
+}
+
+export function stripAutomaticLineBreak(elements: Element[], token: Token | undefined): void {
+  if (!token) return;
+  let index = elements.length - 1;
+  while (index >= 0) {
+    const element = elements[index];
+    if (element?.element !== "text" || !/^[ \t]*$/.test(element.data)) break;
+    index--;
+  }
+  const element = elements[index];
+  if (element && origins.get(element) === token) elements.length = index;
+}

package/src/parser/rules/inline/parsing/block-boundary.ts

@@ -1,3 +1,4 @@
+import { findNoteBounds } from "../../block/note/boundary";
 import type { ParseContext } from "../../types";
 import { INDENT_ACCEPTING_BLOCK_NAMES, KNOWN_BLOCK_NAMES } from "../../../constants";
 import { parseBlockName } from "../../common";
@@ -27,6 +28,7 @@ export function isUnknownBlockToken(ctx: ParseContext, tokenPos: number): boolea
     }
     return true;
   }
+  if (nameResult.name === "note") return findNoteBounds(ctx, tokenPos) === null;
   return !KNOWN_BLOCK_NAMES.has(nameResult.name);
 }
 

package/src/parser/rules/inline/parsing/block-start-predicates.ts

@@ -32,11 +32,21 @@ export function isParagraphBreakingBlockStart(
     !isAnchorName(ctx, nextPos) &&
     !isInvalidBlockOpen(ctx, nextPos) &&
     !isInvalidHeading(ctx, nextPos) &&
+    !isInvalidListMarker(ctx, nextPos) &&
     !isExcludedBlockStart(ctx, nextPos) &&
     !isUnknownBlockStart(ctx, nextPos)
   );
 }
 
+function isInvalidListMarker(ctx: ParseContext, markerPos: number): boolean {
+  const marker = ctx.tokens[markerPos];
+  if (marker?.type !== "LIST_BULLET" && marker?.type !== "LIST_NUMBER") return false;
+
+  // リスト構文はマーカー直後の空白が必須（list/line.tsと同じ規則）。
+  // 空白なしの行（例: 行頭の `*http://...`）はリストにならないため段落境界にもしない
+  return ctx.tokens[markerPos + 1]?.type !== "WHITESPACE";
+}
+
 function isOrphanCloseSpan(ctx: ParseContext, blockEndOpenPos: number): boolean {
   const token = ctx.tokens[blockEndOpenPos];
   if (token?.type !== "BLOCK_END_OPEN") return false;

package/src/parser/rules/inline/parsing/inline-content.ts

@@ -1,3 +1,8 @@
+import { stripAutomaticLineBreak } from "./automatic-line-break";
+import { parseButtonSyntax } from "../button/syntax";
+import { parseSocialSyntax } from "../social/syntax";
+import { parseDateSyntax } from "../date/syntax";
+import { emailRegionEnd } from "../email/candidates";
 import { protectedInlineRegionEnd } from "../raw/end";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
@@ -7,7 +12,10 @@ import {
   type InlineEndType,
 } from "./plain-text";
 import { getParagraphNewlineBoundary } from "./paragraph-boundary";
-import { createPreservedTrailingLineBreak } from "./preserved-line-break";
+import {
+  createPreservedLeadingLineBreak,
+  createPreservedTrailingLineBreak,
+} from "./preserved-line-break";
 import { getCandidateInlineRules } from "./rules";
 import { parseSimpleInlineToken } from "./simple-token";
 
@@ -21,6 +29,7 @@ export interface InlineParseResult {
 
 /**
  * Parse inline content until a specific token type.
+ * EOF mode preserves literal newlines within the inherited inline boundary.
  *
  * When endType is "PARAGRAPH_BREAK", handles NEWLINEs and stops at:
  * - Double NEWLINE (paragraph break)
@@ -31,13 +40,21 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
   const nodes: Element[] = [];
   let consumed = 0;
   let pos = ctx.pos;
+  let consumedEmptyRaw = false;
 
   const paragraphMode = endType === "PARAGRAPH_BREAK";
-  const multiline = paragraphMode || FORMATTING_CLOSE_TOKENS.has(endType);
+  const preserveNewlines = endType === "EOF";
+  const multiline = paragraphMode || preserveNewlines || FORMATTING_CLOSE_TOKENS.has(endType);
   let inlineEnd = ctx.scope.inlineEnd ?? ctx.tokens.length;
   if (!multiline) {
     for (let end = ctx.pos; end < inlineEnd; end++) {
-      const protectedEnd = protectedInlineRegionEnd(ctx.tokens, end, inlineEnd);
+      const protectedEnd = Math.max(
+        parseButtonSyntax(ctx, end, inlineEnd)?.end ?? end,
+        parseSocialSyntax(ctx, end, inlineEnd)?.end ?? end,
+        parseDateSyntax(ctx, end, inlineEnd)?.end ?? end,
+        emailRegionEnd(ctx.tokens, end, inlineEnd),
+        protectedInlineRegionEnd(ctx.tokens, end, inlineEnd),
+      );
       if (protectedEnd > end) {
         end = protectedEnd - 1;
         continue;
@@ -79,6 +96,13 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
       break;
     }
 
+    if (preserveNewlines && token.type === "NEWLINE") {
+      nodes.push({ element: "text", data: token.value });
+      pos++;
+      consumed++;
+      continue;
+    }
+
     if (multiline && token.type === "NEWLINE" && !ctx.scope.tableFormatting) {
       const boundary = getParagraphNewlineBoundary(ctx, pos, nodes.length > 0);
       if (boundary.shouldBreak) {
@@ -97,11 +121,12 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
       continue;
     }
 
-    if (token.type === endType) {
+    const hasEmail = emailRegionEnd(ctx.tokens, pos, inlineEnd) > pos;
+    if (token.type === endType && !hasEmail) {
       break;
     }
 
-    if (canCollectLongPlainTextRuns) {
+    if (canCollectLongPlainTextRuns && !hasEmail) {
       const plainTextRun = collectLongPlainTextRun(ctx, pos, endType);
       if (plainTextRun) {
         nodes.push({ element: "text", data: plainTextRun.value });
@@ -112,7 +137,7 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
     }
 
     const simpleToken = parseSimpleInlineToken(token, ctx.tokens[pos + 1]);
-    if (simpleToken) {
+    if (simpleToken && !hasEmail) {
       nodes.push(simpleToken.element);
       consumed += simpleToken.consumed;
       pos += simpleToken.consumed;
@@ -125,6 +150,10 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
     for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
+        stripAutomaticLineBreak(nodes, result.stripLeadingLineBreak);
+        if (rule.name === "raw" && result.elements.length === 0 && nodes.length === 0) {
+          consumedEmptyRaw = true;
+        }
         if (rule.name === "comment") {
           let after = pos + result.consumed;
           while (ctx.tokens[after]?.type === "WHITESPACE") after++;
@@ -139,7 +168,17 @@ export function parseInlineUntil(ctx: ParseContext, endType: InlineEndType): Inl
             if (nodes.at(-1)?.element === "line-break") nodes.pop();
           }
         }
-        nodes.push(...result.elements);
+        for (const element of result.elements) {
+          nodes.push(
+            paragraphMode &&
+              consumedEmptyRaw &&
+              nodes.length === 0 &&
+              token.type === "NEWLINE" &&
+              element.element === "line-break"
+              ? createPreservedLeadingLineBreak()
+              : element,
+          );
+        }
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;