brookmd 0.29.0 → 0.30.0

package/dist/splice.d.ts

@@ -63,6 +63,41 @@ export declare function noteSplice(next: Block, prev: Block, keep: number): void
  * @internal Renderer-only; not part of the public API.
  */
 export declare function spliceKeep(from: Block, to: Block): number | undefined;
+/**
+ * How an open fence's SPECULATIVE TAIL is painted. The frozen prefix is painted
+ * the same way either way — appended once, never touched again.
+ *
+ * - `"wavefront"` (the default) — the tail is ONE TEXT NODE holding the plain
+ *   source, updated per patch through its character data. No elements are
+ *   created, no markup is parsed, and nothing before it is disturbed, so a patch
+ *   costs the browser a text measure instead of a style/layout pass over a
+ *   freshly built span tree. Colour therefore arrives at the checkpoint — in
+ *   practice one source line behind the stream head.
+ * - `"eager"` — the tail is its highlighted MARKUP, re-parsed on every patch.
+ *   Colour is immediate, at the cost of rebuilding a span-dense subtree per
+ *   frame. This is what the mirror always did.
+ *
+ * Both settle to the same bytes: the tail is thrown away and re-derived at every
+ * patch regardless, and the close-time markup comes from the frozen prefix plus
+ * one final tokenizer run (see hi-inc.ts).
+ */
+export type TailMode = "wavefront" | "eager";
+/**
+ * The markup an open fence's `<code>` holds under `mode` — what the mirror
+ * paints incrementally, and what a caller that cannot mirror (a rebuild, the
+ * test-only full-rebuild reference) has to write in one go so the two agree.
+ *
+ * For `"eager"` that is hi-inc's markup verbatim. For `"wavefront"` the frozen
+ * prefix keeps its spans and the tail is the escaped source, which is exactly
+ * what the tail TEXT NODE serializes to.
+ *
+ * The wavefront tail comes from `st.text`/`st.c` rather than from `markup`,
+ * because the plain source is not recoverable from the tail's markup without
+ * re-parsing it. That is only sound while `markup` is the very string this state
+ * just produced, so a stale pair is handed back untouched rather than paired
+ * with a tail it does not belong to.
+ */
+export declare function incView(st: IncState, markup: string, mode: TailMode): string;
 /**
  * The live `<code>` of an OPEN code block, split the way hi-inc splits its
  * markup: a **frozen** run of children (proven immutable — appended once and
@@ -71,15 +106,17 @@ export declare function spliceKeep(from: Block, to: Block): number | undefined;
  *
  * The two regions are NOT wrapped in elements — `frozenEnd` is simply the last
  * child that belongs to the frozen run — so the resulting `innerHTML` is
- * byte-identical to the `code.innerHTML = markup` this replaces. Only the node
- * *count* differs (a splice can leave two adjacent text nodes where a one-shot
- * parse would have made one), which serializes the same and is exactly what a
- * browser does for any streamed append.
+ * byte-identical to the `code.innerHTML = incView(...)` this replaces. Only the
+ * node *count* differs (a splice can leave two adjacent text nodes where a
+ * one-shot parse would have made one), which serializes the same and is exactly
+ * what a browser does for any streamed append.
  */
 export interface IncCode {
     code: Element;
     /** The language the mirror was built for; a change invalidates it. */
     lang: string;
+    /** How the tail is painted; fixed for the mirror's whole life. */
+    mode: TailMode;
     /** Last child of the frozen run — everything after it is the tail. */
     frozenEnd: ChildNode | null;
     /** Chars of `IncState.frozenHtml` already mirrored into the DOM. */
@@ -93,21 +130,31 @@ export interface IncCode {
      *  else on the streaming path combined. */
     frozenEnd0: ChildNode | null;
     frozenLen0: number;
-    /** The tail markup currently in the DOM, so an unchanged tail is not rewritten. */
+    /** What is on screen after `frozenEnd`, so an unchanged tail is not rewritten:
+     *  the tail MARKUP in `"eager"` mode, the tail SOURCE in `"wavefront"`. */
     tail: string;
+    /** `"wavefront"` only: the single text node carrying the tail source. Created
+     *  once per mirror and then only ever written through its character data —
+     *  that is the whole cost saving, so it is never replaced while it lives. */
+    tailText: Text | null;
 }
 /** A fresh, empty mirror for a `<code>` that has nothing painted into it yet. */
-export declare function newIncCode(code: Element, lang: string, st: IncState): IncCode;
+export declare function newIncCode(code: Element, lang: string, st: IncState, mode: TailMode): IncCode;
 /**
  * Mirror hi-inc's frozen/tail split into a live `<code>`: append whatever the
- * frozen prefix settled since the last patch, then replace the speculative
- * tail. Returns false when the mirror cannot be trusted (see the length
- * invariant below) so the caller falls back to a full node rebuild.
+ * frozen prefix settled since the last patch, then update the speculative tail.
+ * Returns false when the mirror cannot be trusted (see the invariants below) so
+ * the caller falls back to a full node rebuild.
  *
  * Cost per patch is |newly frozen| + |tail|. The frozen term sums, across the
  * whole stream, to one pass over the final markup; the tail is bounded by
- * hi-inc's CAP. That is what makes an open fence linear at the DOM, not just
- * at the tokenizer.
+ * hi-inc's CAP. That is what makes an open fence linear at the DOM, not just at
+ * the tokenizer.
+ *
+ * In `"wavefront"` mode the tail term is also the CHEAPEST shape the DOM has:
+ * one character-data write, no elements created and no markup parsed. Only a
+ * checkpoint advance parses anything, and then only the newly frozen slice — so
+ * span creation drops from (tail spans × patches) to one pass over the block.
  */
 export declare function paintIncCode(ic: IncCode, st: IncState, markup: string): boolean;
 /**

package/dist/splice.js

@@ -1,3 +1,4 @@
+import { escapeHtml } from "./hi.js";
 const SPLICE = /* @__PURE__ */ new WeakMap();
 const SPLICE_DEPTH = 8;
 function noteSplice(next, prev, keep) {
@@ -18,23 +19,31 @@ function spliceKeep(from, to) {
   }
   return void 0;
 }
-function newIncCode(code, lang, st) {
+function incView(st, markup, mode) {
+  if (mode !== "wavefront" || markup !== st.html) return markup;
+  return st.frozenHtml + escapeHtml(st.text.slice(st.c));
+}
+function newIncCode(code, lang, st, mode) {
   return {
     code,
     lang,
+    mode,
     frozenEnd: null,
     frozenLen: 0,
     frozenRev: st.frozenRev,
     frozenEnd0: null,
     frozenLen0: 0,
-    tail: ""
+    tail: "",
+    tailText: null
   };
 }
 function paintIncCode(ic, st, markup) {
   const frozen = st.frozenHtml;
   if (markup.length < frozen.length) return false;
+  const wave = ic.mode === "wavefront";
+  if (wave && markup !== st.html) return false;
   let rewound = ic.frozenRev !== st.frozenRev || frozen.length < ic.frozenLen;
-  const tail = markup.slice(frozen.length);
+  const tail = wave ? st.text.slice(st.c) : markup.slice(frozen.length);
   if (!rewound && frozen.length === ic.frozenLen && tail === ic.tail) return true;
   if (rewound && st.frozenRev === ic.frozenRev + 1 && st.frozenCut === ic.frozenLen0) {
     ic.frozenEnd = ic.frozenEnd0;
@@ -44,23 +53,42 @@ function paintIncCode(ic, st, markup) {
     ic.frozenLen0 = 0;
     rewound = false;
   }
-  const keep = rewound ? null : ic.frozenEnd;
-  while (ic.code.lastChild !== keep) ic.code.removeChild(ic.code.lastChild);
   if (rewound) {
+    while (ic.code.lastChild !== null) ic.code.removeChild(ic.code.lastChild);
     ic.frozenEnd = null;
     ic.frozenLen = 0;
     ic.frozenEnd0 = null;
     ic.frozenLen0 = 0;
     ic.frozenRev = st.frozenRev;
+    ic.tailText = null;
+  } else {
+    const t = ic.tailText;
+    if (t !== null) {
+      while (ic.code.lastChild !== t) ic.code.removeChild(ic.code.lastChild);
+      while (t.previousSibling !== ic.frozenEnd) ic.code.removeChild(t.previousSibling);
+    } else {
+      while (ic.code.lastChild !== ic.frozenEnd) ic.code.removeChild(ic.code.lastChild);
+    }
   }
   if (frozen.length > ic.frozenLen) {
     ic.frozenEnd0 = ic.frozenEnd;
     ic.frozenLen0 = ic.frozenLen;
+    const t = ic.tailText;
+    if (t !== null) ic.code.removeChild(t);
     ic.code.insertAdjacentHTML("beforeend", frozen.slice(ic.frozenLen));
     ic.frozenEnd = ic.code.lastChild;
     ic.frozenLen = frozen.length;
+    if (t !== null) ic.code.appendChild(t);
+  }
+  if (wave) {
+    if (ic.tailText === null && tail !== "") {
+      ic.tailText = ic.code.ownerDocument.createTextNode("");
+      ic.code.appendChild(ic.tailText);
+    }
+    if (ic.tailText !== null) ic.tailText.nodeValue = tail;
+  } else if (tail) {
+    ic.code.insertAdjacentHTML("beforeend", tail);
   }
-  if (tail) ic.code.insertAdjacentHTML("beforeend", tail);
   ic.tail = tail;
   return true;
 }
@@ -204,6 +232,7 @@ function __resetSpliceStats() {
 export {
   __resetSpliceStats,
   __spliceStats,
+  incView,
   newIncCode,
   noteSplice,
   paintIncCode,

package/dist/styles.css

@@ -23,6 +23,13 @@
   --brook-bg-inline: rgba(129, 139, 152, 0.16);
   --brook-bg-quote: rgba(129, 139, 152, 0.08);
   --brook-accent: #0969da;
+  /* alert accents (light) — `note` tracks --brook-accent, so re-theming the
+     link color re-themes the note alert with it. */
+  --brook-alert-note: var(--brook-accent);
+  --brook-alert-tip: #1a7f37;
+  --brook-alert-important: #8250df;
+  --brook-alert-warning: #9a6700;
+  --brook-alert-caution: #cf222e;
   /* syntax tokens (light) */
   --brook-t-kw: #cf222e;
   --brook-t-str: #0a3069;
@@ -39,6 +46,15 @@
   --brook-radius: 6px;
   --brook-gap: 16px;
 
+  /* Motion + caret. Mode-independent (the caret paints in `currentColor`, so it
+     tracks --brook-fg on its own), so unlike the palette these need no dark
+     twin — they sit on the always-matching base selector. Both animations are
+     routed through a variable so the ONE `prefers-reduced-motion` block at the
+     foot of this file switches every one of them off. */
+  --brook-caret: currentColor;
+  --brook-caret-anim: brook-caret-blink 1s steps(2, jump-none) infinite;
+  --brook-pill-anim: brook-pill-pulse 1.6s ease-in-out infinite;
+
   color: var(--brook-fg);
   font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
   line-height: 1.6;
@@ -58,6 +74,10 @@
     --brook-bg-inline: rgba(101, 108, 118, 0.2);
     --brook-bg-quote: rgba(101, 108, 118, 0.1);
     --brook-accent: #4493f8;
+    --brook-alert-tip: #3fb950;
+    --brook-alert-important: #ab7df8;
+    --brook-alert-warning: #d29922;
+    --brook-alert-caution: #f85149;
     --brook-t-kw: #ff7b72;
     --brook-t-str: #a5d6ff;
     --brook-t-num: #79c0ff;
@@ -79,6 +99,10 @@
   --brook-bg-inline: rgba(101, 108, 118, 0.2);
   --brook-bg-quote: rgba(101, 108, 118, 0.1);
   --brook-accent: #4493f8;
+  --brook-alert-tip: #3fb950;
+  --brook-alert-important: #ab7df8;
+  --brook-alert-warning: #d29922;
+  --brook-alert-caution: #f85149;
   --brook-t-kw: #ff7b72;
   --brook-t-str: #a5d6ff;
   --brook-t-num: #79c0ff;
@@ -95,6 +119,25 @@
 .brook-md > * { margin: 0 0 var(--brook-gap) 0; }
 .brook-md > *:last-child { margin-bottom: 0; }
 
+/* Every block the renderers emit on the generic path is wrapped in a
+   layout-transparent `<div class="brook-block brook-block-KIND">`, so the gap
+   above belongs to the WRAPPER and the wrapped element must not stack its own
+   leading/trailing margin on top of it (without this the last block's margin
+   escapes the root and `> *:last-child` above never bites). */
+.brook-md .brook-block > :first-child { margin-top: 0; }
+.brook-md .brook-block > :last-child { margin-bottom: 0; }
+/* …which would also flatten a heading's extra lead-in, so hand that to the
+   wrapper, where it collapses with the previous block's gap instead of adding
+   to it. */
+.brook-md .brook-block-heading { margin-top: 24px; }
+.brook-md > .brook-block-heading:first-child { margin-top: 0; }
+
+/* `brook-speculative` marks a block whose closing delimiter the parser GUESSED
+   and may retract. It is deliberately invisible: a speculative block that looks
+   different from the settled block it becomes would flash on every guess. Kept
+   as a declared hook so overriding it is a one-liner. */
+.brook-md .brook-speculative { --brook-speculative: 1; }
+
 /* ---- headings -------------------------------------------------------------- */
 .brook-md h1, .brook-md h2, .brook-md h3,
 .brook-md h4, .brook-md h5, .brook-md h6 {
@@ -141,6 +184,31 @@
 }
 .brook-md blockquote > :last-child { margin-bottom: 0; }
 
+/* GitHub-style alerts (`> [!NOTE]` &c. — `gfmAlerts`). A colored left rule plus
+   a colored title; the body stays on the page background so a run of alerts
+   does not read as a wall of tinted boxes. */
+.brook-md .markdown-alert {
+  margin: 0 0 var(--brook-gap);
+  padding: 0.4em 1em;
+  border-left: 0.25em solid var(--brook-alert-note);
+  color: inherit;
+}
+.brook-md .markdown-alert > :last-child { margin-bottom: 0; }
+.brook-md .markdown-alert-title {
+  margin: 0 0 0.35em;
+  font-weight: 600;
+  line-height: 1.4;
+  color: var(--brook-alert-note);
+}
+.brook-md .markdown-alert-tip { border-left-color: var(--brook-alert-tip); }
+.brook-md .markdown-alert-tip > .markdown-alert-title { color: var(--brook-alert-tip); }
+.brook-md .markdown-alert-important { border-left-color: var(--brook-alert-important); }
+.brook-md .markdown-alert-important > .markdown-alert-title { color: var(--brook-alert-important); }
+.brook-md .markdown-alert-warning { border-left-color: var(--brook-alert-warning); }
+.brook-md .markdown-alert-warning > .markdown-alert-title { color: var(--brook-alert-warning); }
+.brook-md .markdown-alert-caution { border-left-color: var(--brook-alert-caution); }
+.brook-md .markdown-alert-caution > .markdown-alert-title { color: var(--brook-alert-caution); }
+
 /* ---- tables ---------------------------------------------------------------- */
 .brook-md table { border-collapse: collapse; width: 100%; display: block; overflow-x: auto; }
 .brook-md th, .brook-md td { padding: 6px 13px; border: 1px solid var(--brook-border); }
@@ -186,3 +254,230 @@
 .brook-md .t-var  { color: var(--brook-t-var); }
 .brook-md .t-pun  { color: var(--brook-t-pun); }
 .brook-md .t-txt  { color: inherit; }
+
+/* ---- fenced-block chrome (code / math / mermaid) --------------------------- */
+/* The built-in CodeBlock, MathBlock and Mermaid renderers all emit the same
+   three-part shape:
+     <div class="brook-CHROME-block [brook-streaming]">
+       <div class="brook-CHROME-header">
+         <span class="brook-CHROME-lang">…</span>
+         <span class="brook-code-streaming-pill">streaming</span>   (open)
+         <button class="brook-code-copy">…</button>                 (closed, code only)
+       </div>
+       <div class="brook-CHROME-body">…</div>
+     </div>
+   The container owns the border, the radius and the background; the header is
+   the top edge; the body's `pre` gives all of that up so there is no second
+   frame drawn inside the first. */
+.brook-md .brook-code-block,
+.brook-md .brook-math-block,
+.brook-md .brook-mermaid-block {
+  border: 1px solid var(--brook-border);
+  border-radius: var(--brook-radius);
+  background: var(--brook-bg-code);
+  /* Clips the body's square corners back to the container's radius. */
+  overflow: hidden;
+}
+
+.brook-md .brook-code-header,
+.brook-md .brook-math-header,
+.brook-md .brook-mermaid-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  min-height: 34px;
+  padding: 4px 8px 4px 12px;
+  border-bottom: 1px solid var(--brook-border);
+}
+
+.brook-md .brook-code-lang,
+.brook-md .brook-math-lang,
+.brook-md .brook-mermaid-lang {
+  font-family: ui-monospace, "SF Mono", "JetBrains Mono", Menlo, Consolas, monospace;
+  font-size: 0.75em;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--brook-fg-muted);
+  /* The label is the flex item that may need to shrink; never let a long
+     language name push the copy button off the right edge. */
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Copy button. Ghost by default so the chrome stays quiet until pointed at. */
+.brook-md .brook-code-copy {
+  display: inline-flex;
+  align-items: center;
+  flex: none;
+  gap: 5px;
+  margin: 0;
+  padding: 3px 8px;
+  font: inherit;
+  font-size: 0.75em;
+  line-height: 1.5;
+  color: var(--brook-fg-muted);
+  background: none;
+  border: 1px solid transparent;
+  border-radius: var(--brook-radius);
+  cursor: pointer;
+}
+.brook-md .brook-code-copy:hover {
+  color: var(--brook-fg);
+  background: var(--brook-bg-inline);
+  border-color: var(--brook-border);
+}
+.brook-md .brook-code-copy:focus-visible {
+  outline: 2px solid var(--brook-accent);
+  outline-offset: 1px;
+}
+/* The "copied" state is carried on `aria-label` — the React renderer swaps the
+   prop, the DOM renderer setAttribute()s it — so the accessible name IS the
+   selector. Both adapters revert it after ~1.5s. */
+.brook-md .brook-code-copy[aria-label="Copied"] {
+  color: var(--brook-accent);
+  border-color: currentColor;
+}
+.brook-md .brook-code-copy svg { display: block; flex: none; }
+
+/* "streaming" pill, shown in place of the copy button while a fence is open. */
+.brook-md .brook-code-streaming-pill {
+  display: inline-flex;
+  align-items: center;
+  flex: none;
+  padding: 2px 9px;
+  font-size: 0.7em;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--brook-fg-muted);
+  background: var(--brook-bg-inline);
+  border-radius: 999px;
+  animation: var(--brook-pill-anim);
+}
+
+/* `brook-streaming` (the open-fence modifier) is intentionally inert: the pill
+   above already says "still arriving", and restyling the frame mid-stream would
+   make every fence twitch as it closes. Declared as an override hook. */
+.brook-md .brook-streaming { --brook-streaming: 1; }
+
+/* Body: the `pre` hands its frame to the container and keeps only its padding
+   and its own horizontal scroll. */
+.brook-md .brook-code-body pre,
+.brook-md .brook-mermaid-body pre {
+  margin: 0;
+  border: 0;
+  border-radius: 0;
+  background: none;
+}
+.brook-md .brook-math-body {
+  padding: 14px 16px;
+  overflow-x: auto;
+}
+/* The scrollable code region is focusable (tabIndex=0 on the `pre`, or on the
+   wrapping div before highlighting lands) so it can be scrolled from the
+   keyboard — inset the ring so the clipped container does not eat it. */
+.brook-md .brook-code-body pre:focus-visible,
+.brook-md .brook-code-body > div:focus-visible,
+.brook-md .brook-mermaid-body pre:focus-visible {
+  outline: 2px solid var(--brook-accent);
+  outline-offset: -2px;
+}
+
+/* ---- math ------------------------------------------------------------------ */
+/* Defaults for the zero-dep output (the raw LaTeX in a `.math` node). Kept
+   deliberately thin — no font or color of its own — so dropping a typesetter
+   over these nodes replaces the content without fighting the theme. */
+.brook-md .math.math-display {
+  display: block;
+  overflow-x: auto;
+  text-align: center;
+  margin: var(--brook-gap) 0;
+}
+/* Inside the math chrome the body already supplies the padding. */
+.brook-md .brook-math-body > .math.math-display { margin: 0; }
+.brook-md .math.math-inline { display: inline; }
+
+/* ---- footnotes ------------------------------------------------------------- */
+.brook-md .footnotes {
+  padding-top: var(--brook-gap);
+  border-top: 1px solid var(--brook-border);
+  font-size: 0.875em;
+  color: var(--brook-fg-muted);
+}
+.brook-md .footnotes ol { padding-left: 1.6em; }
+.brook-md .footnotes li { margin: 0.4em 0; }
+.brook-md .footnotes li:target { background: var(--brook-bg-quote); }
+.brook-md sup.footnote-ref { line-height: 0; }
+.brook-md sup.footnote-ref > a { padding: 0 0.15em; text-decoration: none; }
+.brook-md .footnote-backref { margin-left: 0.25em; text-decoration: none; }
+
+/* ---- task lists ------------------------------------------------------------ */
+/* GFM task boxes are rendered `disabled` (they mirror the source, they do not
+   edit it). Keep them legible rather than greyed out, and drop the
+   not-allowed cursor a disabled control would otherwise show. */
+.brook-md input[type="checkbox"][disabled] { opacity: 1; cursor: default; }
+
+/* ---- scroll sentinel ------------------------------------------------------- */
+/* `stickToBottom` appends an empty aria-hidden anchor as the last child of the
+   root. It is a scroll-snap target, not content: it must occupy no space, which
+   means opting out of the root's block gap as well as having no height. */
+.brook-md .brook-bottom-anchor { height: 0; margin: 0; }
+
+/* ---- streaming caret ------------------------------------------------------- */
+/* Opt in per root: `<div class="brook-md brook-caret">`. Draws one blinking bar
+   at the tail of the block still being streamed (`brook-open`). Deliberately
+   NOT drawn inside code/math/mermaid fences — those show the "streaming" pill
+   instead — and each selector below is anchored so exactly one element in an
+   open block can match (a bare `p:last-child` would light up every paragraph in
+   a loose list). Retint with `--brook-caret`, or switch it off wholesale with
+   `.brook-md.brook-caret ::after { content: none }`. */
+.brook-md.brook-caret .brook-open > p:last-child::after,
+.brook-md.brook-caret .brook-open > :is(h1, h2, h3, h4, h5, h6):last-child::after,
+.brook-md.brook-caret .brook-open > blockquote > :last-child:not(pre)::after,
+.brook-md.brook-caret .brook-open > :is(ul, ol) > li:last-child > p:last-child::after,
+.brook-md.brook-caret .brook-open > :is(ul, ol) > li:last-child > :is(ul, ol) > li:last-child > p:last-child::after,
+.brook-md.brook-caret .brook-open table tr:last-child > td:last-child::after {
+  content: "";
+  display: inline-block;
+  width: 0.5em;
+  height: 1em;
+  margin-left: 0.08em;
+  vertical-align: text-bottom;
+  background: var(--brook-caret);
+  animation: var(--brook-caret-anim);
+}
+/* Tight list items (no <p> wrapper) need `:has()` to tell "last leaf item" from
+   "item that contains a nested list". A selector list is all-or-nothing, so
+   these two live in their own rule: an engine without `:has()` drops only the
+   tight-list caret, not the paragraph/heading/quote/table ones above. */
+.brook-md.brook-caret .brook-open > :is(ul, ol) > li:last-child:not(:has(> :is(p, ul, ol)))::after,
+.brook-md.brook-caret .brook-open > :is(ul, ol) > li:last-child > :is(ul, ol) > li:last-child:not(:has(> :is(p, ul, ol)))::after {
+  content: "";
+  display: inline-block;
+  width: 0.5em;
+  height: 1em;
+  margin-left: 0.08em;
+  vertical-align: text-bottom;
+  background: var(--brook-caret);
+  animation: var(--brook-caret-anim);
+}
+
+/* ---- animations ------------------------------------------------------------ */
+@keyframes brook-caret-blink {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+@keyframes brook-pill-pulse {
+  50% { opacity: 0.45; }
+}
+/* One switch for every animation in this file: both are applied through a
+   custom property, and custom properties inherit into `::after`, so redefining
+   them on the root turns the caret and the pill off together. */
+@media (prefers-reduced-motion: reduce) {
+  .brook-md {
+    --brook-caret-anim: none;
+    --brook-pill-anim: none;
+  }
+}

package/dist/svelte.d.ts

@@ -2,7 +2,7 @@ import type { ActionReturn } from "svelte/action";
 import { type Readable } from "svelte/store";
 import { BrookClient } from "./client.js";
 import type { ParserConfig } from "./types-core.js";
-import { type DomComponents } from "./dom.js";
+import { type DomComponents, type LinkClickInfo } from "./dom.js";
 /**
  * Svelte action that mounts a streaming {@link BrookClient} into the host node.
  * Plain `.ts` — no `.svelte` compile step — so `use:` works unchanged in
@@ -20,6 +20,9 @@ export interface BrookMarkdownParams {
     sanitize?: (h: string) => string;
     virtualize?: boolean;
     stickToBottom?: boolean;
+    /** Delegated link-click hook — ONE listener on the renderer root, never per
+     *  anchor (see `MountOptions.onLinkClick`). */
+    onLinkClick?: (event: MouseEvent, link: LinkClickInfo) => void;
 }
 export declare function brookMarkdown(node: HTMLElement, params: BrookMarkdownParams): ActionReturn<BrookMarkdownParams>;
 /**
@@ -65,7 +68,8 @@ export declare function tailBlockId(client: BrookClient): Readable<number | null
  * Lifecycle differs from {@link brookMarkdown}: this action constructs the client
  * once (a later `config` change is ignored, like a created-once instance) and
  * `destroy()`s it on teardown — it OWNS the client. The mount-option reconcile
- * (`components`/`sanitize`/`virtualize`/`stickToBottom`) matches `brookMarkdown`,
+ * (`components`/`sanitize`/`virtualize`/`stickToBottom`/`onLinkClick`) matches
+ * `brookMarkdown`,
  * but the remount reuses the SAME client so its `setContent` diff baseline
  * survives.
  */

package/dist/svelte.js

@@ -1,12 +1,15 @@
 import { readable } from "svelte/store";
 import { BrookClient } from "./client.js";
-import { mountBrookMarkdown, tailOpenBlockId } from "./dom.js";
+import {
+  mountBrookMarkdown,
+  tailOpenBlockId
+} from "./dom.js";
 function brookMarkdown(node, params) {
   let { client, ...options } = params;
   let handle = mountBrookMarkdown(client, node, options);
   return {
     update(next) {
-      if (next.client === client && next.components === options.components && next.sanitize === options.sanitize && next.virtualize === options.virtualize && next.stickToBottom === options.stickToBottom) {
+      if (next.client === client && next.components === options.components && next.sanitize === options.sanitize && next.virtualize === options.virtualize && next.stickToBottom === options.stickToBottom && next.onLinkClick === options.onLinkClick) {
         return;
       }
       handle.destroy();
@@ -39,7 +42,7 @@ function brookMarkdownString(node, params) {
   return {
     update(next) {
       client.setContent(next.content, { done: next.streaming === false });
-      if (next.components === options.components && next.sanitize === options.sanitize && next.virtualize === options.virtualize && next.stickToBottom === options.stickToBottom) {
+      if (next.components === options.components && next.sanitize === options.sanitize && next.virtualize === options.virtualize && next.stickToBottom === options.stickToBottom && next.onLinkClick === options.onLinkClick) {
         return;
       }
       handle.destroy();

package/dist/types-core.d.ts

@@ -48,6 +48,26 @@ export type UrlTransform = (url: string, ctx: {
     tag: string;
     attr: "href" | "src" | "poster";
 }) => string;
+/**
+ * The link a delegated click landed on, handed to every renderer's
+ * `onLinkClick` hook alongside the raw event.
+ *
+ * The hook is DELEGATED by design: ONE listener sits on the renderer's
+ * `.brook-md` root and resolves the anchor from the event target, so turning it
+ * on adds no per-block and no per-anchor work — the streaming path is untouched
+ * and no block's memo/node reuse is affected.
+ *
+ * A still-streaming anchor (`data-brook-pending`: label rendered, URL not yet
+ * arrived) is never reported — there is no `href` to hand you yet.
+ */
+export interface LinkClickInfo {
+    /** The anchor's `href` attribute verbatim, as the core emitted it. */
+    href: string;
+    /** The anchor's rendered text content. */
+    text: string;
+    /** The live `<a>` element that was clicked. */
+    element: HTMLAnchorElement;
+}
 /** Column alignment from the `|:--|:-:|--:|` delimiter row; `null` = unset. */
 export type Align = "left" | "center" | "right" | null;
 /**
@@ -397,7 +417,7 @@ export interface ParserConfig {
     lenientLists?: boolean;
     /**
      * Render a CommonMark SOFT line break (a bare `\n` inside inline content) as
-     * a `<br>` — the `remark-breaks` / "GitHub comment" convention, where one
+     * a `<br>` — the "GitHub comment" convention, where one
      * Enter is one visual line. Default false (strict CommonMark: a soft break is
      * whitespace). Hard breaks (two trailing spaces, or a trailing `\`) are `<br>`
      * either way, so enabling this only ADDS breaks — it never removes one. Chat

package/dist/types-react.d.ts

@@ -2,7 +2,7 @@ import type { ComponentType } from "react";
 import type { BlockComponentProps, BlockKindTag } from "./types-core.js";
 /**
  * Override map for {@link BrookMarkdown}. Keys are either lowercase HTML tag
- * names (`table`, `a`, `code`, `h1`… — react-markdown style, applied inside a
+ * names (`table`, `a`, `code`, `h1`… — applied inside a
  * block's HTML) or capitalized block-kind names (`BlockKindTag`, e.g.
  * `CodeBlock`, `Table` — replace the whole block renderer). Values are a React
  * component or an HTML tag string.

package/dist/vue.d.ts

@@ -1,7 +1,7 @@
 import type { DefineComponent, Ref } from "vue";
 import { BrookClient } from "./client.js";
 import type { ParserConfig } from "./types-core.js";
-import { type DomComponents, type MountOptions } from "./dom.js";
+import { type DomComponents, type LinkClickInfo, type MountOptions } from "./dom.js";
 /**
  * Vue 3 bindings for {@link mountBrookMarkdown}. Thin lifecycle glue: mount the
  * framework-neutral DOM renderer on `onMounted`, tear it down on `onUnmounted`.
@@ -20,12 +20,12 @@ export type UseBrookMarkdownOptions = {
  * `{ container }` — bind it as the `ref` of the element you want filled.
  *
  * `getOpts` must read its fields lazily (e.g. `() => ({ client: props.client,
- * ... })`) so the watcher sees live prop identities. We watch the five
+ * ... })`) so the watcher sees live prop identities. We watch the six
  * identities individually — `[client, components, sanitize, virtualize,
- * stickToBottom]` — rather than a freshly-composed object, which would change
- * identity every call and remount on every patch. On any of those changing we
- * destroy and remount; `batch`/`highlightCode` still flow through to the mount
- * but are intentionally not remount triggers.
+ * stickToBottom, onLinkClick]` — rather than a freshly-composed object, which
+ * would change identity every call and remount on every patch. On any of those
+ * changing we destroy and remount; `batch`/`highlightCode` still flow through to
+ * the mount but are intentionally not remount triggers.
  */
 export declare function useBrookMarkdown(getOpts: () => UseBrookMarkdownOptions): {
     container: Ref<HTMLElement | null>;
@@ -48,6 +48,8 @@ export interface BrookMarkdownVueProps {
     sanitize?: (html: string) => string;
     virtualize?: boolean;
     stickToBottom?: boolean;
+    /** Delegated link-click hook (one listener on the root; see `MountOptions`). */
+    onLinkClick?: (event: MouseEvent, link: LinkClickInfo) => void;
 }
 /**
  * Component wrapper around {@link useBrookMarkdown}. Renders a single `<div>`