@wdprlib/parser 5.3.0 → 5.4.0

package/src/parser/rules/block/note/boundary.ts

@@ -0,0 +1,88 @@
+import type { Token } from "../../../../lexer";
+import type { ParseContext } from "../../types";
+import { createOpaqueProbe, opaqueRuleEnd } from "../../opaque-probe";
+import { codeBlockRule } from "../code";
+import { mathBlockRule } from "../math";
+import { linkTripleRule } from "../../inline/link-triple";
+import { protectedInlineRegionEnd } from "../../inline/raw/end";
+
+// These constructs are replaced before Note in Wikidot's processing order.
+const opaqueRules = [codeBlockRule, mathBlockRule, linkTripleRule];
+interface NoteBounds {
+  bodyStart: number;
+  close: number;
+  end: number;
+}
+const boundsCache = new WeakMap<readonly Token[], Map<number, NoteBounds | null>>();
+const closeCache = new WeakMap<readonly Token[], Map<string, Map<number, number>>>();
+
+function tagEnd(tokens: readonly Token[], pos: number, name: string, close = false): number {
+  return tokens[pos]?.type === (close ? "BLOCK_END_OPEN" : "BLOCK_OPEN") &&
+    tokens[pos + 1]?.value.toLowerCase() === name &&
+    tokens[pos + 2]?.type === "BLOCK_CLOSE"
+    ? pos + 3
+    : pos;
+}
+
+function findClose(probe: ParseContext, start: number, name: string): number {
+  let byName = closeCache.get(probe.tokens);
+  if (!byName) {
+    byName = new Map();
+    closeCache.set(probe.tokens, byName);
+  }
+  let cache = byName.get(name);
+  if (!cache) {
+    cache = new Map();
+    byName.set(name, cache);
+  }
+  if (cache.has(start)) return cache.get(start)!;
+  const visited: number[] = [];
+  let result = -1;
+  for (let pos = start; pos < probe.tokens.length; pos++) {
+    if (cache.has(pos)) {
+      result = cache.get(pos)!;
+      break;
+    }
+    visited.push(pos);
+    const protectedEnd = protectedInlineRegionEnd(probe.tokens, pos, probe.tokens.length);
+    if (protectedEnd > pos) {
+      pos = protectedEnd - 1;
+      continue;
+    }
+    if (tagEnd(probe.tokens, pos, name, true) > pos) {
+      result = pos;
+      break;
+    }
+    const opaqueEnd = opaqueRuleEnd(probe, pos, opaqueRules, true);
+    if (opaqueEnd > pos) {
+      pos = opaqueEnd - 1;
+      continue;
+    }
+    // Footnote precedes Note and uses its first complete close, without nesting.
+    if (name === "note") {
+      const footnoteStart = tagEnd(probe.tokens, pos, "footnote");
+      if (footnoteStart > pos) {
+        const end = findClose(probe, footnoteStart, "footnote");
+        if (end >= 0) pos = end + 2;
+      }
+    }
+  }
+  // Only visited positions are reusable: opaque interiors have different boundaries.
+  for (const pos of visited) cache.set(pos, result);
+  return result;
+}
+
+export function findNoteBounds(ctx: ParseContext, start: number = ctx.pos): NoteBounds | null {
+  const openEnd = tagEnd(ctx.tokens, start, "note");
+  if (openEnd === start || ctx.tokens[openEnd]?.type !== "NEWLINE") return null;
+  let cache = boundsCache.get(ctx.tokens);
+  if (!cache) {
+    cache = new Map();
+    boundsCache.set(ctx.tokens, cache);
+  }
+  if (cache.has(start)) return cache.get(start)!;
+  const close = findClose(createOpaqueProbe(ctx), openEnd + 1, "note");
+  const result = close < 0 ? null : { bodyStart: openEnd + 1, close, end: close + 3 };
+  cache.set(start, result);
+  return result;
+}

package/src/parser/rules/block/note/index.ts

@@ -0,0 +1,37 @@
+import type { BlockRule } from "../../types";
+import { parseBlocksUntil } from "../parsing/content";
+import { findNoteBounds } from "./boundary";
+
+const excludedBlockNames = new Set(["note"]);
+
+export const noteRule: BlockRule = {
+  name: "note",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+  parse(ctx) {
+    const bounds = findNoteBounds(ctx);
+    if (!bounds) return { success: false };
+    const body = parseBlocksUntil(
+      {
+        ...ctx,
+        tokens: ctx.tokens.slice(bounds.bodyStart, bounds.close),
+        pos: 0,
+        scope: {
+          ...ctx.scope,
+          inlineEnd: undefined,
+          tableFormatting: undefined,
+          blockCloseCondition: undefined,
+        },
+      },
+      () => false,
+      { excludedBlockNames },
+    );
+    return {
+      success: true,
+      consumed: bounds.end - ctx.pos,
+      elements: [
+        { element: "container", data: { type: "note", attributes: {}, elements: body.elements } },
+      ],
+    };
+  },
+};

package/src/parser/rules/block/paragraph/index.ts

@@ -1,3 +1,5 @@
+import { markUnparsedDivStart } from "../../../postprocess/divAdjacentParagraph";
+import { isDivClose } from "../div/close";
 /**
  * Paragraph rule
  *
@@ -8,6 +10,7 @@ import type { Element } from "@wdprlib/ast";
 import type { BlockRule, ParseContext, RuleResult } from "../../types";
 import { parseInlineContent } from "./content";
 import { normalizeParagraphElements } from "./normalize";
+import { isPreservedLeadingLineBreak } from "../../inline/parsing/preserved-line-break";
 
 /**
  * Paragraph is the fallback block rule.
@@ -23,18 +26,19 @@ export const paragraphRule: BlockRule = {
 
   parse(ctx: ParseContext): RuleResult<Element> {
     const result = parseInlineContent(ctx);
-    if (result.elements.length === 0) {
+    if (result.consumed === 0) {
       return { success: false };
     }
 
     const elements = normalizeParagraphElements(result.elements);
     if (elements.length === 0) {
-      return { success: false };
+      return { success: true, elements: [], consumed: result.consumed };
     }
 
     const nextPos = ctx.pos + result.consumed;
     const nextToken = ctx.tokens[nextPos];
     if (nextToken?.type === "COLON" && nextToken.lineStart) {
+      if (isPreservedLeadingLineBreak(elements[0])) elements[0] = { element: "line-break" };
       return {
         success: true,
         elements: [...elements, { element: "line-break" }],
@@ -42,9 +46,11 @@ export const paragraphRule: BlockRule = {
       };
     }
 
+    const wrapped = wrapParagraphElements(elements);
+    if (isDivClose(ctx)) markUnparsedDivStart(wrapped);
     return {
       success: true,
-      elements: wrapParagraphElements(elements),
+      elements: wrapped,
       consumed: result.consumed,
     };
   },
@@ -57,7 +63,8 @@ export function wrapParagraphElements(elements: Element[]): Element[] {
   let bare = false;
   const flush = (trimBreaks = false) => {
     const content = trimBreaks ? normalizeParagraphElements(group) : group;
-    while (content[0]?.element === "line-break") content.shift();
+    while (content[0]?.element === "line-break" && !isPreservedLeadingLineBreak(content[0]))
+      content.shift();
     while (content.length) {
       const last = content.at(-1)!;
       if (last.element !== "text" || last.data.trim() !== "") break;
@@ -66,6 +73,7 @@ export function wrapParagraphElements(elements: Element[]): Element[] {
     while (content[0]?.element === "text" && content[0].data.trim() === "") content.shift();
     if (content[0]?.element === "text")
       content[0] = { element: "text", data: content[0].data.trimStart() };
+    if (isPreservedLeadingLineBreak(content[0])) content[0] = { element: "line-break" };
     if (content.length)
       output.push(
         ...(bare || content.some((el) => el.element === "image")

package/src/parser/rules/block/paragraph/normalize.ts

@@ -1,5 +1,6 @@
 import type { Element } from "@wdprlib/ast";
 import { processCloseSpanMarkers } from "./span-markers";
+import { isPreservedLeadingLineBreak } from "../../inline/parsing/preserved-line-break";
 
 type PreservedLineBreak = Extract<Element, { element: "line-break" }> & {
   _preservedTrailingBreak?: boolean;
@@ -44,7 +45,11 @@ function removeTrailingWhitespaceText(elements: Element[]): void {
 
 function removeLeadingLineBreaks(elements: Element[]): Element[] {
   let first = 0;
-  while (first < elements.length && elements[first]?.element === "line-break") {
+  while (
+    first < elements.length &&
+    elements[first]?.element === "line-break" &&
+    !isPreservedLeadingLineBreak(elements[first])
+  ) {
     first++;
   }
 

package/src/parser/rules/block/parsing/block-item.ts

@@ -21,7 +21,7 @@ export function parseBlockItem(ctx: ParseContext): BlockItemResult {
   }
 
   const fallback = ctx.blockFallbackRule.parse(ctx);
-  if (fallback.success && fallback.elements.length > 0) {
+  if (fallback.success) {
     return { elements: fallback.elements, consumed: fallback.consumed };
   }
 

package/src/parser/rules/block/parsing/content.ts

@@ -101,7 +101,7 @@ export function parseBlocksUntil(
     blockCtx.scope = blockScope;
 
     const result = parseBlockItem(blockCtx);
-    elements.push(...result.elements);
+    for (const element of result.elements) elements.push(element);
     consumed += result.consumed;
     pos += result.consumed;
   }

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

@@ -1,3 +1,5 @@
+import { stripAutomaticLineBreak } from "../../inline/parsing/automatic-line-break";
+import { createAutomaticLineBreak } from "../../inline/parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { getCandidateInlineRules } from "../../inline/utils";
@@ -58,7 +60,7 @@ export function parseInlineContentUntil(
       consumed += newlineResult.consumed;
       pos += newlineResult.consumed;
       if (newlineResult.addLineBreak) {
-        elements.push({ element: "line-break" });
+        elements.push(createAutomaticLineBreak(token));
       }
       continue;
     }
@@ -69,7 +71,7 @@ export function parseInlineContentUntil(
     for (const rule of getCandidateBlockRules(blockRules, token)) {
       const result = rule.parse(blockCtx);
       if (result.success) {
-        elements.push(...result.elements);
+        for (const element of result.elements) elements.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;
@@ -84,7 +86,8 @@ export function parseInlineContentUntil(
     for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        elements.push(...result.elements);
+        stripAutomaticLineBreak(elements, result.stripLeadingLineBreak);
+        for (const element of result.elements) elements.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;

package/src/parser/rules/block/table/pipe/cell.ts

@@ -1,3 +1,4 @@
+import { stripAutomaticLineBreak } from "../../../inline/parsing/automatic-line-break";
 import { protectedInlineRegionEnd } from "../../../inline/raw/end";
 import type { Element, TableCell } from "@wdprlib/ast";
 import type { ParseContext } from "../../../types";
@@ -85,7 +86,8 @@ export function parseTableCell(
     for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        children.push(...result.elements);
+        stripAutomaticLineBreak(children, result.stripLeadingLineBreak);
+        for (const element of result.elements) children.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;

package/src/parser/rules/block/table-block/cell-content/index.ts

@@ -69,7 +69,7 @@ export function parseCellContent(
     for (const rule of getCandidateInlineRules(ctx.inlineRules, token.type)) {
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        content.addInlineElements(result.elements);
+        content.addInlineElements(result.elements, result.stripLeadingLineBreak);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;

package/src/parser/rules/block/table-block/cell-content/segments.ts

@@ -1,8 +1,10 @@
+import type { Token } from "../../../../../lexer";
+import { stripAutomaticLineBreak } from "../../../inline/parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 
 export interface CellContentAccumulator {
   addInline(element: Element): void;
-  addInlineElements(elements: Element[]): void;
+  addInlineElements(elements: Element[], stripLeadingLineBreak?: Token): void;
   addBlockElements(elements: Element[]): void;
   addParagraphBreak(): void;
   closeInlineSegmentBeforeBlock(): void;
@@ -40,7 +42,8 @@ export function createCellContentAccumulator(): CellContentAccumulator {
     addInline(element: Element) {
       currentSegment.push(element);
     },
-    addInlineElements(nextElements: Element[]) {
+    addInlineElements(nextElements: Element[], stripLeadingLineBreak?: Token) {
+      stripAutomaticLineBreak(currentSegment, stripLeadingLineBreak);
       currentSegment.push(...nextElements);
     },
     addBlockElements(blockElements: Element[]) {

package/src/parser/rules/block/table-block/cell-newline.ts

@@ -1,3 +1,4 @@
+import { createAutomaticLineBreak } from "../../inline/parsing/automatic-line-break";
 import type { ParseContext } from "../../types";
 import type { CellContentAccumulator } from "./cell-content/segments";
 
@@ -40,7 +41,7 @@ export function consumeCellContentNewline(
   }
 
   if (!content.isEmpty()) {
-    content.addInline({ element: "line-break" });
+    content.addInline(createAutomaticLineBreak(ctx.tokens[startPos]!));
   }
 
   return { consumed };

package/src/parser/rules/contracts/rule.ts

@@ -1,11 +1,13 @@
 import type { Element } from "@wdprlib/ast";
-import type { TokenType } from "../../../lexer";
+import type { Token, TokenType } from "../../../lexer";
 import type { ParseContext } from "./parse-context";
 
 /**
  * Result of a rule attempt.
  */
-export type RuleResult<T> = { success: true; elements: T[]; consumed: number } | { success: false };
+export type RuleResult<T> =
+  | { success: true; elements: T[]; consumed: number; stripLeadingLineBreak?: Token }
+  | { success: false };
 
 /**
  * Block rule interface.

package/src/parser/rules/contracts/scope.ts

@@ -10,6 +10,8 @@ import type { ParseContext } from "./parse-context";
 export interface ScopeContext {
   /** Exclusive token boundary inherited by nested inline rules. */
   readonly inlineEnd?: number;
+  /** Keep bare addresses as text inside an existing anchor. */
+  readonly suppressEmailLinks?: boolean;
   /** Closing delimiters paired across cells of the current pipe table. */
   readonly tableFormatting?: { end: number; suppressedClosers: Set<number> };
   /**

package/src/parser/rules/inline/anchor/child.ts

@@ -1,3 +1,4 @@
+import type { Token } from "../../../../lexer";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { inlineRules } from "../index";
@@ -6,6 +7,7 @@ import { getCandidateInlineRules } from "../utils";
 export interface AnchorChildResult {
   elements: Element[];
   consumed: number;
+  stripLeadingLineBreak?: Token;
 }
 
 export function parseAnchorChild(ctx: ParseContext, pos: number): AnchorChildResult {
@@ -14,11 +16,15 @@ export function parseAnchorChild(ctx: ParseContext, pos: number): AnchorChildRes
     return { elements: [], consumed: 0 };
   }
 
-  const inlineCtx: ParseContext = { ...ctx, pos };
+  const inlineCtx: ParseContext = {
+    ...ctx,
+    pos,
+    scope: { ...ctx.scope, suppressEmailLinks: true },
+  };
   for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
     const result = rule.parse(inlineCtx);
     if (result.success) {
-      return { elements: result.elements, consumed: result.consumed };
+      return result;
     }
   }
 

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

@@ -1,3 +1,4 @@
+import { stripAutomaticLineBreak } from "../parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { parseAnchorChild } from "./child";
@@ -50,7 +51,8 @@ export function parseAnchorContent(
     }
 
     const child = parseAnchorChild(ctx, pos);
-    children.push(...child.elements);
+    stripAutomaticLineBreak(children, child.stripLeadingLineBreak);
+    for (const element of child.elements) children.push(element);
     pos += child.consumed;
     consumed += child.consumed;
   }

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

@@ -1,3 +1,4 @@
+import { precedingSingleNewline } from "../parsing/automatic-line-break";
 /**
  *
  * Parses the Wikidot anchor inline block syntax: `[[a]]...[[/a]]`.
@@ -10,7 +11,8 @@
  * - `[[a_ href="url"]]text[[/a]]` -- paragraph strip mode (trailing underscore)
  *
  * Paragraph strip mode (`[[a_]]`) suppresses newlines within the anchor
- * body and strips at most one trailing newline after the closing tag
+ * body and strips at most one automatic newline before the opening tag
+ * and one trailing newline after the closing tag
  * (preserving double newlines as paragraph breaks). This prevents
  * unwanted `<br>` elements when consecutive anchor blocks are placed on
  * separate lines.
@@ -98,6 +100,7 @@ export const anchorRule: InlineRule = {
         },
       ],
       consumed,
+      stripLeadingLineBreak: openResult.paragraphStrip ? precedingSingleNewline(ctx) : undefined,
     };
   },
 };

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

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

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

@@ -0,0 +1,153 @@
+/**
+ *
+ * Parses bare URLs in plain text into links (auto-linking).
+ *
+ * Wikidot converts bare URLs like `http://example.com/page` into
+ * `<a href="URL">URL</a>` without any bracket syntax. A `*` prefix
+ * (`*http://...`) opens the link in a new tab.
+ *
+ * Mirrors Text_Wiki's Url rule (Parse/Default/Url.php):
+ * - Recognized schemes: `http://`, `https://`, `ftp://`, `gopher://`,
+ *   `news://`, `mms://`, and `mailto:`
+ * - A URL is only recognized at line start or after a non-alphabetic
+ *   character (`(^|[^A-Za-z])` in the original regex)
+ * - The final character of a URL must be alphanumeric or one of
+ *   `%/?=&~_`, so trailing punctuation (`.`, `,`, `)` etc.) stays as text
+ *
+ * Produces a `"link"` AST element with `type: "direct"`.
+ *
+ * @module
+ */
+import type { AnchorTarget, Element } from "@wdprlib/ast";
+import type { TokenType } from "../../../lexer";
+import { URL_PATTERN, URL_SCHEME_NAMES } from "../../../lexer/url-schemes";
+import type { InlineRule, ParseContext, RuleResult } from "../types";
+import { rawRegionEnd } from "./raw/end";
+
+/**
+ * Structural block/link delimiters that terminate a bare URL. Wikitext
+ * constructs like `[[span]]…[[/span]]` and `[[[page]]]` are resolved before
+ * URLs in Text_Wiki (their bodies are delimiter-wrapped), so a bare URL must
+ * not swallow the enclosing scope's close marker (e.g. the `[[/span]]` in
+ * `[[span]]http://x/[[/span]]`).
+ */
+const URL_BOUNDARY_TOKENS: ReadonlySet<TokenType> = new Set<TokenType>([
+  "WHITESPACE",
+  "NEWLINE",
+  "EOF",
+  "BLOCK_OPEN",
+  "BLOCK_END_OPEN",
+  "BLOCK_CLOSE",
+  "LINK_OPEN",
+  "LINK_CLOSE",
+  "COMMENT_OPEN",
+  "BACKSLASH_BREAK",
+]);
+
+/**
+ * Inline rule for auto-linking bare URLs.
+ *
+ * Triggered by an `IDENTIFIER` token whose value is a URL scheme name,
+ * or by a `*` prefix (`STAR` mid-line, `LIST_BULLET` at line start —
+ * the list rule requires a space after the marker, so `*http://...`
+ * falls through to inline parsing).
+ */
+export const autolinkRule: InlineRule = {
+  name: "autolink",
+  startTokens: ["IDENTIFIER", "STAR", "LIST_BULLET"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    let pos = ctx.pos;
+    let target: AnchorTarget | null = null;
+
+    const first = ctx.tokens[pos];
+    if (!first) {
+      return { success: false };
+    }
+
+    if (first.type === "STAR" || first.type === "LIST_BULLET") {
+      if (first.value !== "*") {
+        return { success: false };
+      }
+      target = "new-tab";
+      pos++;
+    }
+
+    const scheme = ctx.tokens[pos];
+    if (scheme?.type !== "IDENTIFIER" || !URL_SCHEME_NAMES.has(scheme.value)) {
+      return { success: false };
+    }
+    if (ctx.tokens[pos + 1]?.type !== "COLON") {
+      return { success: false };
+    }
+
+    // Text_Wikiの前置条件 `(^|[^A-Za-z])`: 行頭または非英字の直後でのみURLと認識する
+    const prev = ctx.tokens[ctx.pos - 1];
+    if (prev && !first.lineStart) {
+      const lastChar = prev.value[prev.value.length - 1] ?? "";
+      if (/[A-Za-z]/.test(lastChar)) {
+        return { success: false };
+      }
+    }
+
+    // URL候補: 空白・改行・構造デリミタの手前までのトークン列を文字列として連結する。
+    // ブロック/リンクの開閉トークン（[[ ]] [[/ [[[ ]]]）で止めることで、
+    // 囲みスコープの閉じマーカー（[[/span]]等）をURLに取り込まないようにする
+    const values: string[] = [];
+    let end = pos;
+    const inlineEnd = ctx.scope.inlineEnd ?? ctx.tokens.length;
+    while (end < inlineEnd) {
+      const token = ctx.tokens[end];
+      if (!token || URL_BOUNDARY_TOKENS.has(token.type)) {
+        break;
+      }
+      if (token.type === "RAW_OPEN" || token.type === "RAW_BLOCK_OPEN") {
+        if (rawRegionEnd(ctx.tokens, end, inlineEnd) > end) break;
+      }
+      values.push(token.value);
+      end++;
+      // Compact TEXT tokens can contain whitespace; do not scan subsequent URLs again.
+      if (/[ \t\n\\"']/.test(token.value)) break;
+    }
+
+    const candidate = values.join("");
+    const match = URL_PATTERN.exec(candidate);
+    if (!match) {
+      return { success: false };
+    }
+
+    // マッチ全体を含むところまでトークンを消費する。大きなソースの一括テキスト化では
+    // `page. b` のようにURL末尾と後続テキストが同一トークンに融合するため、マッチ終端が
+    // トークン中間に落ちた場合は残り部分をテキスト要素として返す
+    const url = match[0];
+    let length = 0;
+    let count = 0;
+    while (length < url.length) {
+      length += values[count]?.length ?? 0;
+      count++;
+    }
+    const rest = candidate.slice(url.length, length);
+
+    const elements: Element[] = [
+      {
+        element: "link",
+        data: {
+          type: "direct",
+          link: url,
+          extra: null,
+          label: { text: url },
+          target,
+        },
+      },
+    ];
+    if (rest !== "") {
+      elements.push({ element: "text", data: rest });
+    }
+
+    return {
+      success: true,
+      elements,
+      consumed: pos - ctx.pos + count,
+    };
+  },
+};

package/src/parser/rules/inline/button/attributes.ts

@@ -0,0 +1,17 @@
+/** Button's quoted attributes use Text_Wiki's getAttrs splitting rules. */
+export function parseButtonAttributes(source: string): Record<string, string> {
+  const sections = source.trim().split('="');
+  const attrs: Record<string, string> = {};
+  let key = sections[0]!.trim();
+  for (const section of sections.slice(1)) {
+    const quote = section.lastIndexOf('"');
+    if (quote < 0) continue;
+    if (key === "text" || key === "class" || key === "style") {
+      attrs[key] = section
+        .slice(0, quote)
+        .replace(/\\([\s\S]|$)/g, (_match, char: string) => (char === "0" ? "\0" : char));
+    }
+    key = section.slice(quote + 1).trim();
+  }
+  return attrs;
+}

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

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