brookmd 0.26.1 → 0.28.0

package/dist/hi-defer.js

@@ -8,12 +8,15 @@ function __setSliceMs(ms) {
 }
 const noop = () => {
 };
-function highlightWithin(code, lang) {
-  const state = { pos: 0, out: "" };
+function seeded(seed) {
+  return seed === void 0 ? { pos: 0, out: "" } : { pos: seed.pos, out: seed.out };
+}
+function highlightWithin(code, lang, seed) {
+  const state = seeded(seed);
   return runSlice(code, lang, state) ? state.out : null;
 }
-function highlightDeferred(code, lang) {
-  const state = { pos: 0, out: "" };
+function highlightDeferred(code, lang, seed) {
+  const state = seeded(seed);
   if (runSlice(code, lang, state)) {
     return { html: state.out, rest: null, cancel: noop };
   }

package/dist/hi-inc.d.ts

@@ -0,0 +1,127 @@
+import { type HighlightState } from "./hi.js";
+/**
+ * How an unbounded opener recognizes its terminator, with the O(1) state each
+ * one carries between patches:
+ *
+ * - `char` — the first occurrence of `ch` closes (`[^ch]*ch` forms: Go raw
+ *   strings, HTML/CSS attribute strings, Rust `#[…]`, Bash `'…'` and `${…}`).
+ * - `starSlash` — `prevStar`, for `/* … *\/`.
+ * - `dashGt` — `dashRun`, for `<!-- … -->`.
+ * - `esc` — `esc`, for backslash-escaped strings and template literals. A
+ *   backslash immediately before a newline is {@link DEAD}, not an escape: the
+ *   pattern's `\\.` does not match a newline, so the form can never close.
+ * - `triple` — `runLen`, for Python `"""` / `'''`.
+ * - `dbl` — `pendingQuote`, for SQL's doubled-quote escaping (`'a''b'`).
+ */
+type PredKind = {
+    k: "char";
+    ch: string;
+} | {
+    k: "starSlash";
+} | {
+    k: "dashGt";
+} | {
+    k: "esc";
+    ch: string;
+} | {
+    k: "triple";
+    ch: string;
+} | {
+    k: "dbl";
+    ch: string;
+};
+/** @internal */
+export interface Opener {
+    /** Sticky regex for the OPENING delimiter only — bounded, O(1) to test. */
+    re: RegExp;
+    /** The pattern class the tokenizer emits when this form IS terminated. */
+    cls: string;
+    /** The literal terminator. */
+    end: string;
+    pred: PredKind;
+}
+/** @internal The carried state of one opener's continuation predicate. */
+export interface OpenerScanState {
+    n: number;
+    f: boolean;
+}
+/** Per-block incremental state. Create with {@link createInc}, feed {@link incHighlight}. */
+export interface IncState {
+    /** The language key this state's tables were chosen for. */
+    readonly lang: string;
+    /** Settled through here: `[0, c)` of the source will never re-tokenize. */
+    c: number;
+    /** Markup for `[0, c)`. Always a byte-prefix of the block's final markup. */
+    frozenHtml: string;
+    /**
+     * Bumped whenever `frozenHtml` is TRUNCATED or cleared — the one checkpoint of
+     * rewind {@link adopt} performs, or a restart. It never moves while the prefix
+     * merely GROWS.
+     *
+     * A renderer that mirrors the frozen prefix into the DOM append-only reads it
+     * as the "may I splice?" token: same rev ⇒ the prefix only grew, so appending
+     * `frozenHtml.slice(alreadyWritten)` is exact; a changed rev means the prefix
+     * was rewritten underneath and the mirror must be re-seeded. Length alone is
+     * NOT enough — one call can rewind to `c0` and then re-freeze past the old
+     * length, which looks like a plain append but is not one.
+     */
+    frozenRev: number;
+    /**
+     * The length `frozenHtml` was TRUNCATED to at the last {@link frozenRev} bump:
+     * `frozenLen0` for {@link adopt}'s one-checkpoint rewind, `0` for a restart.
+     *
+     * The rev alone says "rewritten"; this says *from where*, which is what lets a
+     * DOM mirror rewind to a boundary it already holds instead of re-seeding the
+     * whole run. It is load-bearing that this is reported rather than inferred:
+     * `adopt` frequently rewinds and then re-freezes PAST the old length within
+     * the same call, so the observable `frozenHtml.length` can come back unchanged
+     * while its bytes have moved.
+     */
+    frozenCut: number;
+    /** The checkpoint BEFORE `c`, and the `frozenHtml` length that went with it —
+     *  the one step of rewind a tail revision needs (see {@link adopt}). */
+    c0: number;
+    frozenLen0: number;
+    /** The unbounded opener live at the tail, or `null`. */
+    opener: Opener | null;
+    /** `opener`'s carried predicate state. */
+    scan: OpenerScanState;
+    /** `opener` can never close — stop re-scanning and render the tail plain. */
+    sealed: boolean;
+    /** The source last fed in, for the append/revision guard. */
+    text: string;
+    /** Escaped source for `[c, plainUpto)` — the plain tail, extended in place. */
+    plain: string;
+    plainFrom: number;
+    plainUpto: number;
+    /** The markup last handed out, so a repeated feed of the same text is free. */
+    html: string | null;
+}
+/**
+ * State for a block in `lang`, or `null` when the language has no table (the
+ * plain-escape fallback has no token boundaries to checkpoint on).
+ */
+export declare function createInc(lang: string): IncState | null;
+/**
+ * Feed the block's CURRENT full source and get the markup for all of it, or
+ * `null` when the incremental path has bowed out (past {@link CLIFF}) and the
+ * caller should render the plain escaped body exactly as it does today.
+ *
+ * Calls must be append-only. Anything else — a `reset()`, a speculative tail
+ * revision, one block's id being reused for different content — is detected
+ * (`text.startsWith(prev)`, the same guard the DOM renderer's prefix-append fast
+ * path uses) and simply restarts the state from scratch.
+ */
+export declare function incHighlight(st: IncState, text: string): string | null;
+/**
+ * The `{pos, out}` a close-time `highlightWithin`/`highlightDeferred` run should
+ * resume from, or `undefined` when nothing was frozen or the state does not
+ * belong to `text`/`lang` (a revised block, a different language, a block that
+ * crossed the cliff). Then the close-time run is the unseeded one it always was.
+ */
+export declare function incSeed(st: IncState, text: string, lang: string): HighlightState | undefined;
+/** @internal Test-only: total source bytes re-tokenized since the last reset. */
+export declare function __getIncScanned(): number;
+/** @internal Test-only. */
+export declare function __resetIncScanned(): void;
+export {};

package/dist/hi-inc.js

@@ -0,0 +1,323 @@
+import { escapeHtml, stepHighlight } from "./hi.js";
+const GAP = 3;
+const CAP = 8192;
+const CLIFF = 5e4;
+const OPEN = 0;
+const CLOSED = 1;
+const DEAD = 2;
+const BLOCK_COMMENT = { re: /\/\*/y, cls: "com", end: "*/", pred: { k: "starSlash" } };
+const JS_OPENERS = [
+  BLOCK_COMMENT,
+  { re: /`/y, cls: "str", end: "`", pred: { k: "esc", ch: "`" } }
+];
+const RUST_OPENERS = [
+  BLOCK_COMMENT,
+  { re: /b?"/y, cls: "str", end: '"', pred: { k: "esc", ch: '"' } },
+  { re: /#!?\[/y, cls: "attr", end: "]", pred: { k: "char", ch: "]" } }
+];
+const PY_OPENERS = [
+  { re: /[fFrRbB]{0,2}"""/y, cls: "str", end: '"""', pred: { k: "triple", ch: '"' } },
+  { re: /[fFrRbB]{0,2}'''/y, cls: "str", end: "'''", pred: { k: "triple", ch: "'" } }
+];
+const GO_OPENERS = [
+  BLOCK_COMMENT,
+  { re: /`/y, cls: "str", end: "`", pred: { k: "char", ch: "`" } }
+];
+const BASH_OPENERS = [
+  { re: /"/y, cls: "str", end: '"', pred: { k: "esc", ch: '"' } },
+  { re: /'/y, cls: "str", end: "'", pred: { k: "char", ch: "'" } },
+  { re: /\$\{/y, cls: "var", end: "}", pred: { k: "char", ch: "}" } }
+];
+const SQL_OPENERS = [
+  BLOCK_COMMENT,
+  { re: /'/y, cls: "str", end: "'", pred: { k: "dbl", ch: "'" } },
+  { re: /"/y, cls: "str", end: '"', pred: { k: "dbl", ch: '"' } }
+];
+const HTML_OPENERS = [
+  { re: /<!--/y, cls: "com", end: "-->", pred: { k: "dashGt" } },
+  { re: /"/y, cls: "str", end: '"', pred: { k: "char", ch: '"' } },
+  { re: /'/y, cls: "str", end: "'", pred: { k: "char", ch: "'" } }
+];
+const CSS_OPENERS = [
+  BLOCK_COMMENT,
+  { re: /"/y, cls: "str", end: '"', pred: { k: "char", ch: '"' } },
+  { re: /'/y, cls: "str", end: "'", pred: { k: "char", ch: "'" } }
+];
+const OPENERS = {
+  js: JS_OPENERS,
+  javascript: JS_OPENERS,
+  ts: JS_OPENERS,
+  tsx: JS_OPENERS,
+  jsx: JS_OPENERS,
+  typescript: JS_OPENERS,
+  rust: RUST_OPENERS,
+  rs: RUST_OPENERS,
+  py: PY_OPENERS,
+  python: PY_OPENERS,
+  go: GO_OPENERS,
+  bash: BASH_OPENERS,
+  sh: BASH_OPENERS,
+  shell: BASH_OPENERS,
+  json: [],
+  sql: SQL_OPENERS,
+  html: HTML_OPENERS,
+  xml: HTML_OPENERS,
+  css: CSS_OPENERS
+};
+const GT_CHECKPOINT = /* @__PURE__ */ new Set(["html", "xml"]);
+function createInc(lang) {
+  const key = lang.toLowerCase();
+  if (!Object.prototype.hasOwnProperty.call(OPENERS, key)) return null;
+  return {
+    lang: key,
+    c: 0,
+    frozenHtml: "",
+    frozenRev: 0,
+    frozenCut: 0,
+    c0: 0,
+    frozenLen0: 0,
+    opener: null,
+    scan: { n: 0, f: false },
+    sealed: false,
+    text: "",
+    plain: "",
+    plainFrom: 0,
+    plainUpto: 0,
+    html: null
+  };
+}
+function divergence(a, b) {
+  const n = a.length < b.length ? a.length : b.length;
+  let i = 0;
+  while (i < n && a.charCodeAt(i) === b.charCodeAt(i)) i++;
+  return i;
+}
+function adopt(st, d) {
+  if (st.c > 0 && d >= st.c + GAP) {
+    dropTail(st);
+    return true;
+  }
+  if (st.c0 > 0 && d >= st.c0 + GAP) {
+    st.frozenHtml = st.frozenHtml.slice(0, st.frozenLen0);
+    st.frozenRev++;
+    st.frozenCut = st.frozenLen0;
+    st.c = st.c0;
+    st.c0 = 0;
+    st.frozenLen0 = 0;
+    dropTail(st);
+    return true;
+  }
+  return false;
+}
+function dropTail(st) {
+  st.opener = null;
+  st.scan = { n: 0, f: false };
+  st.sealed = false;
+  st.plain = "";
+  st.plainFrom = st.c;
+  st.plainUpto = st.c;
+  st.html = null;
+}
+function reset(st) {
+  st.c = 0;
+  st.frozenHtml = "";
+  st.frozenRev++;
+  st.frozenCut = 0;
+  st.c0 = 0;
+  st.frozenLen0 = 0;
+  st.opener = null;
+  st.scan = { n: 0, f: false };
+  st.sealed = false;
+  st.text = "";
+  st.plain = "";
+  st.plainFrom = 0;
+  st.plainUpto = 0;
+  st.html = null;
+}
+function incHighlight(st, text) {
+  if (st.text === text) return st.html;
+  const d = divergence(st.text, text);
+  const appended = d === st.text.length && text.length > st.text.length;
+  let from = st.text.length;
+  if (!appended) {
+    if (!adopt(st, d)) reset(st);
+    from = 0;
+  }
+  st.text = text;
+  if (text.length > CLIFF) {
+    reset(st);
+    st.text = text;
+    return null;
+  }
+  const live = st.opener;
+  if (live !== null) {
+    const r = st.sealed ? OPEN : feed(live.pred, st.scan, text, from, text.length);
+    if (r === DEAD) st.sealed = true;
+    if (r !== CLOSED) {
+      st.html = st.frozenHtml + plainTail(st, text);
+      return st.html;
+    }
+    st.opener = null;
+  }
+  if (text.length - st.c > CAP) {
+    st.html = st.frozenHtml + plainTail(st, text);
+    return st.html;
+  }
+  st.html = rescan(st, text);
+  return st.html;
+}
+function incSeed(st, text, lang) {
+  if (st.c === 0 || st.lang !== lang.toLowerCase()) return void 0;
+  if (text.length > CLIFF || text.length < st.c) return void 0;
+  if (!text.startsWith(st.text.slice(0, st.c))) return void 0;
+  return { pos: st.c, out: st.frozenHtml };
+}
+let scanned = 0;
+function __getIncScanned() {
+  return scanned;
+}
+function __resetIncScanned() {
+  scanned = 0;
+}
+function plainTail(st, text) {
+  if (st.plainFrom !== st.c || st.plainUpto > text.length) {
+    st.plainFrom = st.c;
+    st.plain = "";
+    st.plainUpto = st.c;
+  }
+  if (st.plainUpto < text.length) {
+    st.plain += escapeHtml(text.slice(st.plainUpto));
+    st.plainUpto = text.length;
+  }
+  return st.plain;
+}
+function rescan(st, text) {
+  const openers = OPENERS[st.lang];
+  const gt = GT_CHECKPOINT.has(st.lang);
+  const limit = text.length - GAP;
+  let cp = -1;
+  let cpOut = 0;
+  let liveAt = -1;
+  let liveOp = null;
+  let liveLen = 0;
+  const sink = (cls, start, end, outLen) => {
+    if (liveAt >= 0) return;
+    for (let i = 0; i < openers.length; i++) {
+      const op = openers[i];
+      op.re.lastIndex = start;
+      const m = op.re.exec(text);
+      if (m === null || m.index !== start) continue;
+      const terminated = cls === op.cls && end - start >= m[0].length + op.end.length && text.startsWith(op.end, end - op.end.length);
+      if (terminated) continue;
+      liveAt = start;
+      liveOp = op;
+      liveLen = m[0].length;
+      return;
+    }
+    if (gt) {
+      if (cls === "pun" && end - start === 1 && text.charCodeAt(start) === 62 && end <= limit) {
+        cp = end;
+        cpOut = outLen;
+      }
+      return;
+    }
+    if (cls !== "ws") return;
+    const hi = end < limit ? end : limit;
+    if (hi <= start) return;
+    const nl = text.lastIndexOf("\n", hi - 1);
+    if (nl < start) return;
+    cp = nl + 1;
+    cpOut = outLen - (end - cp);
+  };
+  const state = { pos: st.c, out: "" };
+  scanned += text.length - st.c;
+  while (!stepHighlight(text, st.lang, state, text.length, sink)) {
+  }
+  const full = st.frozenHtml + state.out;
+  if (cp > st.c) {
+    st.c0 = st.c;
+    st.frozenLen0 = st.frozenHtml.length;
+    st.frozenHtml += state.out.slice(0, cpOut);
+    st.c = cp;
+  }
+  const found = liveOp;
+  if (found === null) {
+    st.opener = null;
+  } else {
+    st.scan = { n: 0, f: false };
+    const r = feed(found.pred, st.scan, text, liveAt + liveLen, text.length);
+    st.opener = r === CLOSED ? null : found;
+    st.sealed = r === DEAD;
+  }
+  return full;
+}
+function feed(p, st, s, from, to) {
+  switch (p.k) {
+    case "char": {
+      const i = s.indexOf(p.ch, from);
+      return i >= 0 && i < to ? CLOSED : OPEN;
+    }
+    case "starSlash": {
+      for (let i = from; i < to; i++) {
+        const ch = s[i];
+        if (st.f && ch === "/") return CLOSED;
+        st.f = ch === "*";
+      }
+      return OPEN;
+    }
+    case "dashGt": {
+      for (let i = from; i < to; i++) {
+        const ch = s[i];
+        if (ch === ">" && st.n >= 2) return CLOSED;
+        st.n = ch === "-" ? st.n + 1 : 0;
+      }
+      return OPEN;
+    }
+    case "esc": {
+      for (let i = from; i < to; i++) {
+        const ch = s[i];
+        if (st.f) {
+          st.f = false;
+          if (ch === "\n") return DEAD;
+          continue;
+        }
+        if (ch === "\\") {
+          st.f = true;
+          continue;
+        }
+        if (ch === p.ch) return CLOSED;
+      }
+      return OPEN;
+    }
+    case "triple": {
+      for (let i = from; i < to; i++) {
+        if (s[i] === p.ch) {
+          st.n++;
+          if (st.n === 3) return CLOSED;
+        } else {
+          st.n = 0;
+        }
+      }
+      return OPEN;
+    }
+    case "dbl": {
+      for (let i = from; i < to; i++) {
+        const ch = s[i];
+        if (st.f) {
+          st.f = false;
+          if (ch !== p.ch) return CLOSED;
+          continue;
+        }
+        if (ch === p.ch) st.f = true;
+      }
+      return OPEN;
+    }
+  }
+}
+export {
+  __getIncScanned,
+  __resetIncScanned,
+  createInc,
+  incHighlight,
+  incSeed
+};

package/dist/hi.d.ts

@@ -8,6 +8,7 @@
  * highlight an open (streaming) block, which avoids re-highlighting the same
  * code on every chunk — the main perf win for streaming code.
  */
+export declare function escapeHtml(s: string): string;
 /**
  * The resumable tokenizer's cursor: `pos` is the next source index to consume,
  * `out` the markup emitted so far. Start a run at `{ pos: 0, out: "" }`.
@@ -16,6 +17,21 @@ export interface HighlightState {
     pos: number;
     out: string;
 }
+/**
+ * Called once per token the tokenizer emits, AFTER its markup is appended:
+ * `(cls, start, end, outLen)` where `cls` is the PATTERN class (`ws`, `str`,
+ * `com`, `pun`, `ident`… — not the `kw`/`fn`/`ty` refinement), `[start, end)` is
+ * the source span, and `outLen` is `state.out.length` once the token has been
+ * written. The catch-all one-character fallback reports `cls === ""`.
+ *
+ * Passing no sink is the default and costs one `undefined` test per token; the
+ * escape-fallback path (unknown language / over the size guard) emits no tokens
+ * and so reports nothing.
+ *
+ * @internal The incremental streaming path (hi-inc.ts) is the only consumer —
+ * it needs token boundaries to pick a checkpoint that survives an append.
+ */
+export type TokenSink = (cls: string, start: number, end: number, outLen: number) => void;
 /**
  * One resumable slice of {@link highlight}. Consumes WHOLE tokens from
  * `state.pos` until at least `chars` source characters have been taken (or the
@@ -32,6 +48,6 @@ export interface HighlightState {
  *
  * @internal Not part of the semver surface — use {@link highlight}.
  */
-export declare function stepHighlight(code: string, lang: string, state: HighlightState, chars: number): boolean;
+export declare function stepHighlight(code: string, lang: string, state: HighlightState, chars: number, sink?: TokenSink): boolean;
 export declare function highlight(code: string, lang: string): string;
 export declare function supportedLangs(): string[];

package/dist/hi.js

@@ -169,7 +169,7 @@ function escapeHtml(s) {
   }
   return out + s.slice(last);
 }
-function stepHighlight(code, lang, state, chars) {
+function stepHighlight(code, lang, state, chars, sink) {
   const conf = code.length > 5e4 ? void 0 : LANGS[lang.toLowerCase()];
   const stop = state.pos + (chars > 0 ? chars : 1);
   if (!conf) {
@@ -201,6 +201,7 @@ function stepHighlight(code, lang, state, chars) {
           finalCls = "ty";
         } else {
           out += escapeHtml(text);
+          if (sink) sink(cls, pos, after, out.length);
           pos = after;
           matched = true;
           break;
@@ -211,12 +212,14 @@ function stepHighlight(code, lang, state, chars) {
       } else {
         out += `<span class="t-${finalCls}">${escapeHtml(text)}</span>`;
       }
+      if (sink) sink(cls, pos, after, out.length);
       pos = after;
       matched = true;
       break;
     }
     if (!matched) {
       out += escapeHtml(code[pos]);
+      if (sink) sink("", pos, pos + 1, out.length);
       pos += 1;
     }
   }
@@ -234,6 +237,7 @@ function supportedLangs() {
   return Object.keys(LANGS);
 }
 export {
+  escapeHtml,
   highlight,
   stepHighlight,
   supportedLangs

package/dist/html-to-react.d.ts

@@ -19,6 +19,8 @@ type HNode = {
  */
 export declare function parseStyle(css: string): Record<string, string>;
 export declare function getParseCount(): number;
+/** @internal Test-only. Characters of markup handed to the tokenizer so far. */
+export declare function getParseChars(): number;
 export declare function resetParseCount(): void;
 export declare function parseTrustedHtml(html: string): HNode[];
 /**

package/dist/html-to-react.js

@@ -131,14 +131,20 @@ function parseOpenTag(html, start) {
   return { tag, attrs, selfClose: false, next: i };
 }
 let parseCount = 0;
+let parseChars = 0;
 function getParseCount() {
   return parseCount;
 }
+function getParseChars() {
+  return parseChars;
+}
 function resetParseCount() {
   parseCount = 0;
+  parseChars = 0;
 }
 function parseTrustedHtml(html) {
   parseCount++;
+  parseChars += html.length;
   const root = [];
   const stack = [];
   let i = 0;
@@ -357,6 +363,7 @@ function wrapLink(text, attrs) {
 }
 export {
   decodeEntities,
+  getParseChars,
   getParseCount,
   htmlToReact,
   parseStyle,

package/dist/react-splice.d.ts

@@ -0,0 +1,32 @@
+import { type MutableRefObject } from "react";
+import type { Block } from "./types-core.js";
+/**
+ * Let a layout effect own an element's children so an OPEN block's patch is
+ * applied incrementally (see splice.ts) instead of re-setting the whole
+ * `dangerouslySetInnerHTML` every time it grows.
+ *
+ * ## How React and the effect share the node
+ *
+ * The returned string is the html captured on the FIRST render and never
+ * changes again. Render it as the node's `__html` and React writes the element
+ * exactly once, at mount — its own `lastHtml !== nextHtml` check then keeps it
+ * from touching the children on any later commit, and the effect owns them from
+ * there.
+ *
+ * That is what makes this safe under concurrent rendering: a render that is
+ * thrown away commits nothing and runs no effect, and the effect's own
+ * bookkeeping makes a repeat run (StrictMode's double-invoke) a no-op. It also
+ * leaves SSR and hydration byte-identical, because the first markup React
+ * produces is still the block's full html.
+ *
+ * The caller hands the node BACK to React by rendering a different element
+ * (a closed block's plain `<div dangerouslySetInnerHTML>`), which remounts the
+ * subtree and re-renders the settled html in one pass.
+ *
+ * @param hostRef ref attached to the element whose children are managed
+ * @param block   the block's CURRENT version (identity matters — `spliceKeep`
+ *                is keyed on it)
+ * @param enabled false to stay entirely out of the way
+ * @returns the html to render as `__html`, or `null` when not managing
+ */
+export declare function useHtmlSplice(hostRef: MutableRefObject<HTMLElement | null>, block: Block | undefined, enabled: boolean): string | null;

package/dist/react-splice.js

@@ -0,0 +1,33 @@
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { spliceHtml, spliceKeep } from "./splice.js";
+const useIsoLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function useHtmlSplice(hostRef, block, enabled) {
+  const seed = useRef(block);
+  const applied = useRef(null);
+  useIsoLayoutEffect(() => {
+    const base = seed.current;
+    if (!enabled || block === void 0 || base === void 0) {
+      applied.current = null;
+      return;
+    }
+    const node = hostRef.current;
+    if (node === null) return;
+    let prev = applied.current;
+    if (prev === null || prev.node !== node) prev = { node, block: base };
+    if (prev.block === block) {
+      applied.current = prev;
+      return;
+    }
+    const keep = spliceKeep(prev.block, block);
+    if (keep !== void 0 && spliceHtml(node, prev.block.html, block.html, keep)) {
+      applied.current = { node, block };
+      return;
+    }
+    node.innerHTML = block.html;
+    applied.current = { node, block };
+  });
+  return enabled && seed.current !== void 0 ? seed.current.html : null;
+}
+export {
+  useHtmlSplice
+};

package/dist/react.d.ts

@@ -128,6 +128,31 @@ interface BrookMarkdownProps {
      * applies only to the streaming tail.
      */
     childMemo?: boolean;
+    /**
+     * Highlight a code fence **while it is still streaming**, instead of showing
+     * plain escaped text until it closes. On by default.
+     *
+     * An open block keeps a frozen prefix and re-tokenizes only its tail on each
+     * patch, so this stays linear in the block's size (it does not re-highlight
+     * the whole fence per chunk). The settled markup is byte-identical either way
+     * — only the tail's colours are provisional, and they may shift as bytes
+     * arrive (`"hello` is a stray quote plus an identifier until its closing quote
+     * lands). Set `false` for the pre-0.27 behaviour: plain body until close.
+     *
+     * No effect on SSR (the server renders closed blocks only), and none at all
+     * when `components.CodeBlock` / `components.pre` / `components.code` take over
+     * the block — an override bypasses the built-in highlighter entirely.
+     */
+    streamingHighlight?: boolean;
+    /**
+     * @internal TEST-ONLY. Turn off the incremental apply paths (the open code
+     * block's frozen/tail mirror and the open generic block's delta splice) so
+     * every patch re-renders the whole block through React, exactly as it did
+     * before they existed. The DOM-parity fuzz renders one tree with it on and one
+     * with it off and asserts their markup matches after every commit. Not part of
+     * the supported API.
+     */
+    __fullRebuild?: boolean;
     /** Appended to the root's `className` (the `brook-md` class is always present). */
     className?: string;
     /** Set on the root element. */
@@ -264,6 +289,9 @@ interface BlockViewProps {
     virtualize?: boolean;
     sanitize?: (html: string) => string;
     childMemo?: boolean;
+    streamingHighlight?: boolean;
+    /** @internal TEST-ONLY — see BrookMarkdownProps.__fullRebuild. */
+    __fullRebuild?: boolean;
     onRenderMetrics?: RenderMetricsHook;
     decorators?: Decorator[];
     urlTransform?: UrlTransform;