@wdprlib/parser 5.3.0 → 5.4.0

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";
 
@@ -31,13 +39,20 @@ 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);
   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;
@@ -97,11 +112,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 +128,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 +141,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 +159,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;

package/src/parser/rules/inline/parsing/plain-text.ts

@@ -1,4 +1,6 @@
+import { getEmailCandidate } from "../email/candidates";
 import type { TokenType } from "../../../../lexer";
+import { URL_SCHEME_NAMES } from "../../../../lexer/url-schemes";
 import type { ParseContext } from "../../types";
 
 const MIN_INLINE_TEXT_RUN_LENGTH = 32;
@@ -18,6 +20,7 @@ export function collectLongPlainTextRun(
 ): PlainTextRun | null {
   const firstToken = ctx.tokens[startPos];
   if (
+    !getEmailCandidate(ctx.tokens, startPos) &&
     firstToken?.type === "TEXT" &&
     firstToken.value.length >= MIN_INLINE_TEXT_RUN_LENGTH &&
     firstToken.value !== "("
@@ -50,10 +53,12 @@ export function collectLongPlainTextRun(
 
 function isPlainTextRunToken(ctx: ParseContext, pos: number): boolean {
   const token = ctx.tokens[pos];
-  if (!token) return false;
+  if (!token || getEmailCandidate(ctx.tokens, pos)) return false;
 
   if (token.type === "IDENTIFIER") {
-    return true;
+    // 連続平文の一括テキスト化がURL先頭のスキーム名を取り込むと
+    // autolinkルールに到達しなくなるため、スキーム名の手前で止める
+    return !(URL_SCHEME_NAMES.has(token.value) && ctx.tokens[pos + 1]?.type === "COLON");
   }
 
   if (token.type === "WHITESPACE") {

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

@@ -2,6 +2,7 @@ import type { Element } from "@wdprlib/ast";
 
 type PreservedLineBreak = Extract<Element, { element: "line-break" }> & {
   _preservedTrailingBreak?: boolean;
+  _preservedLeadingBreak?: boolean;
 };
 
 export function createPreservedTrailingLineBreak(): Element {
@@ -9,3 +10,15 @@ export function createPreservedTrailingLineBreak(): Element {
   lineBreak._preservedTrailingBreak = true;
   return lineBreak;
 }
+
+export function createPreservedLeadingLineBreak(): Element {
+  const lineBreak: PreservedLineBreak = { element: "line-break", _preservedLeadingBreak: true };
+  return lineBreak;
+}
+
+export function isPreservedLeadingLineBreak(element: Element | undefined): boolean {
+  return (
+    element?.element === "line-break" &&
+    (element as PreservedLineBreak)._preservedLeadingBreak === true
+  );
+}

package/src/parser/rules/inline/parsing/raw-tag.ts

@@ -0,0 +1,19 @@
+import type { Token } from "../../../../lexer";
+
+const unclosedRanges = new WeakMap<readonly Token[], { start: number; end: number }>();
+
+/** Raw directives end at the first ]], even inside a quoted value. */
+export function findRawTagClose(
+  tokens: readonly Token[],
+  start: number,
+  end: number,
+): number | null {
+  const unclosed = unclosedRanges.get(tokens);
+  if (unclosed && start >= unclosed.start && end <= unclosed.end) return null;
+  for (let close = start; close < end; close++) {
+    if (tokens[close]?.type === "BLOCK_CLOSE") return close;
+    if (!tokens[close] || tokens[close]?.type === "EOF") break;
+  }
+  unclosedRanges.set(tokens, { start, end });
+  return null;
+}

package/src/parser/rules/inline/raw/angle.ts

@@ -1,4 +1,5 @@
 import type { Element } from "@wdprlib/ast";
+import { decodeHTML } from "entities";
 import type { ParseContext, RuleResult } from "../../types";
 import { currentToken, hasClosingMarkerBeforeNewline } from "../../types";
 import { rawElement, textElement } from "./result";
@@ -36,5 +37,5 @@ export function parseAngleRaw(ctx: ParseContext): RuleResult<Element> {
     consumed++;
   }
 
-  return rawElement(value, consumed);
+  return rawElement(decodeHTML(value), consumed);
 }

package/src/parser/rules/inline/raw/end.ts

@@ -1,15 +1,35 @@
 import type { Token } from "../../../../lexer";
 
+// A failed angle-raw search also rules out later openers within the same immutable token range.
+const unclosedAngleRanges = new WeakMap<
+  readonly Token[],
+  { start: number; end: number; lineEnd: boolean }
+>();
+
 /** Exclusive end of a complete single-line raw region, or the original position. */
 export function rawRegionEnd(tokens: readonly Token[], start: number, end: number): number {
   const type = tokens[start]?.type;
   const close =
     type === "RAW_OPEN" ? "RAW_OPEN" : type === "RAW_BLOCK_OPEN" ? "RAW_BLOCK_CLOSE" : null;
   if (!close) return start;
+  const cached = type === "RAW_BLOCK_OPEN" ? unclosedAngleRanges.get(tokens) : undefined;
+  if (
+    cached &&
+    start >= cached.start &&
+    start < cached.end &&
+    (cached.lineEnd || end <= cached.end)
+  ) {
+    return start;
+  }
   for (let pos = start + 1; pos < end; pos++) {
-    if (tokens[pos]?.type === "NEWLINE" || tokens[pos]?.type === "EOF") break;
+    if (tokens[pos]?.type === "NEWLINE" || tokens[pos]?.type === "EOF") {
+      if (type === "RAW_BLOCK_OPEN")
+        unclosedAngleRanges.set(tokens, { start, end: pos, lineEnd: true });
+      return start;
+    }
     if (tokens[pos]?.type === close) return pos + 1;
   }
+  if (type === "RAW_BLOCK_OPEN") unclosedAngleRanges.set(tokens, { start, end, lineEnd: false });
   return start;
 }
 

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

@@ -32,7 +32,7 @@ export function parseSizeContent(ctx: ParseContext, startPos: number): SizeConte
     const inlineCtx: ParseContext = { ...ctx, pos };
     const inlineResult = parseInlineUntil(inlineCtx, "BLOCK_END_OPEN");
     if (inlineResult.elements.length > 0) {
-      children.push(...inlineResult.elements);
+      for (const element of inlineResult.elements) children.push(element);
       pos += inlineResult.consumed;
       consumed += inlineResult.consumed;
     } else {

package/src/parser/rules/inline/size/value.ts

@@ -1,6 +1,16 @@
 import type { ParseContext } from "../../types";
 
 const VALID_SIZE_UNITS = ["px", "em", "rem", "ex", "%", "cm", "mm", "in", "pc"];
+const VALID_SIZE_KEYWORDS = [
+  "smaller",
+  "larger",
+  "xx-small",
+  "x-small",
+  "small",
+  "large",
+  "x-large",
+  "xx-large",
+];
 
 export function parseSizeValue(
   ctx: ParseContext,
@@ -40,6 +50,7 @@ export function parseSizeValue(
 }
 
 function isValidSizeValue(size: string): boolean {
+  if (VALID_SIZE_KEYWORDS.includes(size)) return true;
   const unitPattern = VALID_SIZE_UNITS.join("|");
   return new RegExp(`^(\\d+(?:\\.\\d+)?)(${unitPattern})$`, "i").test(size);
 }

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

@@ -0,0 +1,17 @@
+import type { InlineRule } from "../../types";
+import { parseSocialSyntax } from "./syntax";
+
+export const socialRule: InlineRule = {
+  name: "social",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const result = parseSocialSyntax(ctx, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    return result
+      ? {
+          success: true,
+          consumed: result.end - ctx.pos,
+          elements: [{ element: "social", data: result.data }],
+        }
+      : { success: false };
+  },
+};

package/src/parser/rules/inline/social/syntax.ts

@@ -0,0 +1,40 @@
+import type { SocialData } from "@wdprlib/ast";
+import type { Token } from "../../../../lexer";
+import type { ParseContext } from "../../types";
+import { findRawTagClose } from "../parsing/raw-tag";
+
+const invalidBodies = new WeakMap<readonly Token[], { start: number; bracket: number }>();
+
+export function parseSocialSyntax(
+  ctx: ParseContext,
+  start: number,
+  end: number,
+): { data: SocialData; end: number } | null {
+  const tokens = ctx.tokens;
+  if (tokens[start]?.type !== "BLOCK_OPEN" || tokens[start + 1]?.value.toLowerCase() !== "social")
+    return null;
+  const bodyStart = start + 2;
+  if (tokens[bodyStart]?.type !== "BLOCK_CLOSE" && !/^\s+$/.test(tokens[bodyStart]?.value ?? ""))
+    return null;
+  const invalid = invalidBodies.get(tokens);
+  if (invalid && bodyStart >= invalid.start && bodyStart <= invalid.bracket) return null;
+  const close = findRawTagClose(tokens, bodyStart, end);
+  if (close === null) return null;
+  for (let pos = bodyStart; pos < close; pos++) {
+    if (tokens[pos]!.value.includes("]")) {
+      invalidBodies.set(tokens, { start: bodyStart, bracket: pos });
+      return null;
+    }
+  }
+  const body = tokens
+    .slice(bodyStart, close)
+    .map((token) => token.value)
+    .join("");
+  const sites = body.trim()
+    ? body
+        .split(",")
+        .map((site) => site.trim().toLowerCase())
+        .filter(Boolean)
+    : null;
+  return { data: { sites }, end: close + 1 };
+}

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

@@ -1,3 +1,4 @@
+import { stripAutomaticLineBreak } from "../parsing/automatic-line-break";
 import { rawRegionEnd } from "../raw/end";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
@@ -118,7 +119,8 @@ function parseOneSpanChild(
   for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
     const result = rule.parse(inlineCtx);
     if (result.success) {
-      targetChildren.push(...result.elements);
+      stripAutomaticLineBreak(targetChildren, result.stripLeadingLineBreak);
+      for (const element of result.elements) targetChildren.push(element);
       return { consumed: result.consumed };
     }
   }

package/src/parser/rules/inline/span/newline.ts

@@ -1,3 +1,4 @@
+import { createAutomaticLineBreak } from "../parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 
@@ -38,7 +39,7 @@ export function consumeSpanNewline(
   }
 
   const targetChildren = paragraphStrip && afterBlankLine ? escapedChildren : children;
-  targetChildren.push({ element: "line-break" });
+  targetChildren.push(createAutomaticLineBreak(ctx.tokens[pos]!));
   let consumed = 1;
   let nextPos = pos + 1;
   while (ctx.tokens[nextPos]?.type === "WHITESPACE" && ctx.tokens[nextPos]?.lineStart) {