@drscrewdriver/dsh-better-display 0.3.3-fork.1

package/lib/types/client/markdown/MarkdownText.js

@@ -0,0 +1,178 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Adapted from DeepSeek Harness b150a551b8d465e31e418e1b2eaf5e79bbb7d28e (MIT). See THIRD_PARTY_NOTICES.md.
+/**
+ * Untrusted assistant-Markdown renderer over the direct mdast pipeline:
+ * `parse.ts` grammars, the incremental streaming parser, and `render.tsx`.
+ * While a message streams, all but the trailing two blocks freeze as cached
+ * React elements and only the source tail behind them re-parses per chunk,
+ * so per-chunk work tracks the tail size instead of the whole reply. Frozen
+ * blocks keep their source-offset keys when they cross the freeze boundary,
+ * so React reconciles instead of remounting. Known deviation while
+ * streaming: a reference-style link or footnote whose definition sits on the
+ * other side of the freeze boundary renders literally until the settled
+ * full parse self-heals it.
+ */
+import { memo, useMemo, useRef } from 'react';
+import { IncrementalMarkdownParser } from './incremental.js';
+import { parseGfm, parseGfmWithMath } from './parse.js';
+import { collectReferenceTargets, createReferenceTargets, renderBlocks, renderFootnoteSection, wrapBlockChildren, } from './render.js';
+// KaTeX CSS is supplied once by the shared DSH UI-primitives client bundle.
+import css from './MarkdownText.module.css';
+/** One settled full render: parse with math, resolve references, append the footnote section. */
+function renderSettled(text, codeLabels, fileMentions, pathImages, renderText, renderAtom) {
+    const root = parseGfmWithMath(text);
+    const targets = createReferenceTargets();
+    collectReferenceTargets(root.children, targets);
+    const context = {
+        renderText,
+        renderAtom,
+        streaming: false,
+        codeLabels,
+        fileMentions,
+        pathImages,
+        targets,
+        footnoteOrder: [],
+        footnoteCounts: new Map(),
+    };
+    const blocks = wrapBlockChildren(renderBlocks(root.children.map((node, index) => ({ node, key: node.position?.start.offset ?? -(index + 1) })), context), false);
+    const section = renderFootnoteSection(context);
+    return section === null ? blocks : [...blocks, '\n', section];
+}
+/**
+ * Streaming render state for one growing message: the incremental parser,
+ * the frozen blocks' cached elements, and the reference/footnote state their
+ * rendering consumed (footnote numbering assigned to frozen references is
+ * final, so the tail continues from a copy of it each frame).
+ */
+class StreamingRenderer {
+    codeLabels;
+    renderText;
+    renderAtom;
+    pathImages;
+    parser = new IncrementalMarkdownParser(parseGfm);
+    generation = -1;
+    frozenCount = 0;
+    frozenElements = [];
+    frozenTargets = createReferenceTargets();
+    frozenFootnoteOrder = [];
+    frozenFootnoteCounts = new Map();
+    lastText = null;
+    lastRendered = [];
+    /** @param codeLabels - Fence copy labels baked into cached elements; the owner replaces the renderer when they change. */
+    constructor(codeLabels, renderText, renderAtom, pathImages) {
+        this.codeLabels = codeLabels;
+        this.renderText = renderText;
+        this.renderAtom = renderAtom;
+        this.pathImages = pathImages;
+    }
+    /**
+     * Render the current accumulated text. Idempotent per text value, so React
+     * may re-execute the calling render freely.
+     * @param text - The full accumulated markdown source.
+     * @returns Frozen elements, re-rendered tail, and the footnote section.
+     */
+    render(text) {
+        if (text === this.lastText)
+            return this.lastRendered;
+        const { frozen, tail, generation } = this.parser.update(text);
+        if (generation !== this.generation) {
+            this.generation = generation;
+            this.frozenCount = 0;
+            this.frozenElements = [];
+            this.frozenTargets = createReferenceTargets();
+            this.frozenFootnoteOrder = [];
+            this.frozenFootnoteCounts = new Map();
+        }
+        const newlyFrozen = frozen.slice(this.frozenCount);
+        collectReferenceTargets(newlyFrozen.map(block => block.node), this.frozenTargets);
+        // Targets visible this frame: everything frozen so far plus the current
+        // tail parse — a newly frozen block's references resolved against the
+        // same parse tree its definitions came from.
+        const frameTargets = {
+            definitions: new Map(this.frozenTargets.definitions),
+            footnotes: new Map(this.frozenTargets.footnotes),
+        };
+        collectReferenceTargets(tail.map(block => block.node), frameTargets);
+        if (newlyFrozen.length > 0) {
+            const frozenContext = {
+                renderText: this.renderText,
+                renderAtom: this.renderAtom,
+                streaming: true,
+                codeLabels: this.codeLabels,
+                fileMentions: undefined,
+                pathImages: this.pathImages,
+                targets: frameTargets,
+                footnoteOrder: this.frozenFootnoteOrder,
+                footnoteCounts: this.frozenFootnoteCounts,
+            };
+            // Separator newlines are cached alongside the elements so the
+            // assembled children match the settled pipeline's block wrapping.
+            const batch = [...this.frozenElements];
+            for (const element of renderBlocks(newlyFrozen, frozenContext)) {
+                if (batch.length > 0)
+                    batch.push('\n');
+                batch.push(element);
+            }
+            this.frozenElements = batch;
+            this.frozenCount = frozen.length;
+        }
+        const tailContext = {
+            renderText: this.renderText,
+            renderAtom: this.renderAtom,
+            streaming: true,
+            codeLabels: this.codeLabels,
+            fileMentions: undefined,
+            pathImages: this.pathImages,
+            targets: frameTargets,
+            footnoteOrder: [...this.frozenFootnoteOrder],
+            footnoteCounts: new Map(this.frozenFootnoteCounts),
+        };
+        const children = [...this.frozenElements];
+        for (const element of renderBlocks(tail, tailContext)) {
+            if (children.length > 0)
+                children.push('\n');
+            children.push(element);
+        }
+        const section = renderFootnoteSection(tailContext);
+        if (section !== null)
+            children.push('\n', section);
+        this.lastText = text;
+        this.lastRendered = children;
+        return this.lastRendered;
+    }
+}
+/**
+ * Render untrusted assistant-authored Markdown as semantic React elements.
+ * @param props - Markdown source text preserved by the session projection;
+ * `streaming` renders fences and TeX plain (highlighting and KaTeX land on
+ * the finalize swap) and parses incrementally across chunks; `codeLabels`
+ * forwards localized copy-button labels to fence CodeBlocks — pass a
+ * reference-stable object (memoized per locale revision), because a new
+ * identity discards the streaming render cache mid-message. `fileMentions`
+ * links inline-code tokens its resolver recognizes as real files; this is
+ * the single streaming gate — it applies to settled renders only, because a
+ * streaming message's vocabulary is not final and frozen cached elements
+ * must not bake in handlers that could go stale.
+ * @returns A GFM document with TeX math rendered through KaTeX; raw HTML,
+ * relative links, and unsafe protocols are disabled, while absolute HTTP(S)
+ * images render directly.
+ */
+export const MarkdownText = memo(function MarkdownText({ text, streaming = false, codeLabels, fileMentions, pathImages, renderText, renderAtom }) {
+    const streamRef = useRef(null);
+    const streamImagesRef = useRef(pathImages);
+    const streamLabelsRef = useRef(codeLabels);
+    const children = useMemo(() => {
+        if (!streaming) {
+            streamRef.current = null;
+            return renderSettled(text, codeLabels, fileMentions, pathImages, renderText, renderAtom);
+        }
+        if (streamRef.current === null || streamLabelsRef.current !== codeLabels || streamImagesRef.current !== pathImages) {
+            streamRef.current = new StreamingRenderer(codeLabels, renderText, renderAtom, pathImages);
+            streamLabelsRef.current = codeLabels;
+            streamImagesRef.current = pathImages;
+        }
+        return streamRef.current.render(text);
+    }, [text, streaming, codeLabels, fileMentions, pathImages, renderText, renderAtom]);
+    return _jsx("div", { className: css.markdown, children: children });
+});
+//# sourceMappingURL=MarkdownText.js.map

package/lib/types/client/markdown/MarkdownText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownText.js","sourceRoot":"","sources":["../../../../src/client/markdown/MarkdownText.tsx"],"names":[],"mappings":"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"}

package/lib/types/client/markdown/cjkFriendlyStrong.d.ts

@@ -0,0 +1,9 @@
+/** Let asterisk strong emphasis close after punctuation when CJK prose continues without whitespace. */
+import type { Extension } from 'micromark-util-types';
+/**
+ * Extend CommonMark asterisk strong emphasis for punctuation-delimited CJK
+ * prose, as a micromark syntax extension for `fromMarkdown`.
+ * @returns The micromark syntax extension.
+ */
+export declare function cjkFriendlyStrong(): Extension;
+//# sourceMappingURL=cjkFriendlyStrong.d.ts.map

package/lib/types/client/markdown/cjkFriendlyStrong.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cjkFriendlyStrong.d.ts","sourceRoot":"","sources":["../../../../src/client/markdown/cjkFriendlyStrong.ts"],"names":[],"mappings":"AACA,wGAAwG;AAMxG,OAAO,KAAK,EAAa,SAAS,EAAoB,MAAM,sBAAsB,CAAA;AAqElF;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,SAAS,CAE7C"}

package/lib/types/client/markdown/cjkFriendlyStrong.js

@@ -0,0 +1,73 @@
+// Adapted from DeepSeek Harness b150a551b8d465e31e418e1b2eaf5e79bbb7d28e (MIT). See THIRD_PARTY_NOTICES.md.
+/** Let asterisk strong emphasis close after punctuation when CJK prose continues without whitespace. */
+import { attention } from 'micromark-core-commonmark';
+import { unicodePunctuation } from 'micromark-util-character';
+import { classifyCharacter } from 'micromark-util-classify-character';
+import { codes, constants } from 'micromark-util-symbol';
+const cjkCharacter = new RegExp([
+    '\\p{Script_Extensions=Han}',
+    '\\p{Script_Extensions=Hiragana}',
+    '\\p{Script_Extensions=Katakana}',
+    '\\p{Script_Extensions=Hangul}',
+    '\\p{Script_Extensions=Bopomofo}',
+].join('|'), 'u');
+function isCjkCharacter(code) {
+    return code !== null && code >= 0 && cjkCharacter.test(String.fromCodePoint(code));
+}
+const tokenizeCjkFriendlyAttention = function (effects, ok, nok) {
+    const configuredAttentionMarkers = this.parser.constructs.attentionMarkers.null;
+    if (configuredAttentionMarkers === undefined) {
+        throw new Error('micromark CommonMark attention markers are unavailable');
+    }
+    const attentionMarkers = configuredAttentionMarkers;
+    const previous = this.previous;
+    const before = classifyCharacter(previous);
+    let marker = codes.eof;
+    return start;
+    function start(code) {
+        /* v8 ignore next -- this text construct is dispatched only for an asterisk. */
+        if (code !== codes.asterisk)
+            return nok(code);
+        marker = code;
+        effects.enter('attentionSequence');
+        return inside(code);
+    }
+    function inside(code) {
+        if (code === marker) {
+            effects.consume(code);
+            return inside;
+        }
+        const token = effects.exit('attentionSequence');
+        const after = classifyCharacter(code);
+        const open = !after || (after === constants.characterGroupPunctuation && Boolean(before))
+            || attentionMarkers.includes(code);
+        const commonMarkClose = !before
+            || (before === constants.characterGroupPunctuation && Boolean(after))
+            || attentionMarkers.includes(previous);
+        const markerCount = token.end.offset - token.start.offset;
+        const cjkStrongClose = markerCount >= 2
+            && unicodePunctuation(previous)
+            && isCjkCharacter(code);
+        const close = commonMarkClose || cjkStrongClose;
+        token._open = open;
+        token._close = close;
+        return ok(code);
+    }
+};
+const cjkFriendlyAttention = {
+    name: 'cjkFriendlyAttention',
+    resolveAll: attention.resolveAll,
+    tokenize: tokenizeCjkFriendlyAttention,
+};
+const cjkFriendlyStrongExtension = {
+    text: { [codes.asterisk]: cjkFriendlyAttention },
+};
+/**
+ * Extend CommonMark asterisk strong emphasis for punctuation-delimited CJK
+ * prose, as a micromark syntax extension for `fromMarkdown`.
+ * @returns The micromark syntax extension.
+ */
+export function cjkFriendlyStrong() {
+    return cjkFriendlyStrongExtension;
+}
+//# sourceMappingURL=cjkFriendlyStrong.js.map

package/lib/types/client/markdown/cjkFriendlyStrong.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cjkFriendlyStrong.js","sourceRoot":"","sources":["../../../../src/client/markdown/cjkFriendlyStrong.ts"],"names":[],"mappings":"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"}

package/lib/types/client/markdown/incremental.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Incremental block-level markdown parsing for an append-only text stream.
+ *
+ * Re-parsing the whole accumulated document on every streaming chunk is
+ * quadratic in the final reply length. CommonMark block parsing is line-based
+ * and appended text can only reshape the parse frontier — the last top-level
+ * block (a paragraph becoming a setext heading or a table, a list continuing
+ * after a blank line, an unclosed fence swallowing lines) — so earlier blocks
+ * are final. This parser therefore freezes all but the trailing
+ * {@link UNSTABLE_TAIL_BLOCKS} blocks and re-parses only the source tail
+ * behind them: each source region is parsed O(1) times over the stream
+ * instead of once per chunk.
+ *
+ * The freeze boundary comes from the parser's own `position` offsets, never
+ * from custom source scanning. The cut sits at the *end offset* of the last
+ * frozen block (not the next block's start): a following block's start offset
+ * excludes up to three spaces of insignificant leading indentation, which is
+ * harmless to drop, but cutting at the previous end also keeps the
+ * inter-block blank lines in the tail so the sliced source stays verbatim.
+ *
+ * Known deviation, shared with any prefix-freeze scheme: micromark resolves
+ * reference-style links and footnotes document-wide at parse time, so a
+ * reference whose definition lands on the other side of the freeze boundary
+ * renders literally until the settled full parse self-heals it.
+ */
+import type { Root, RootContent } from 'mdast';
+/** A top-level mdast block plus a render key that is stable across chunks. */
+export interface PositionedBlock {
+    /** The parsed block. Positions inside it are relative to its parse slice. */
+    readonly node: RootContent;
+    /**
+     * The block's start offset in the full source text. Stable from the frame
+     * a block first appears through freezing, so React reconciles rather than
+     * remounts when a block crosses the freeze boundary.
+     */
+    readonly key: number;
+}
+/** One {@link IncrementalMarkdownParser.update} result. */
+export interface IncrementalBlocks {
+    /** Blocks that can no longer change; grows monotonically per generation. */
+    readonly frozen: readonly PositionedBlock[];
+    /** The re-parsed unstable tail (at most {@link UNSTABLE_TAIL_BLOCKS} blocks plus growth). */
+    readonly tail: readonly PositionedBlock[];
+    /** Bumped whenever non-append input discards the frozen prefix; callers drop caches keyed on it. */
+    readonly generation: number;
+}
+/**
+ * Append-only incremental parser over a caller-supplied grammar. One instance
+ * accumulates one streaming document; non-append input resets it.
+ */
+export declare class IncrementalMarkdownParser {
+    private readonly parse;
+    private prevText;
+    private tailStart;
+    private frozen;
+    private generation;
+    private cached;
+    /** @param parse - Grammar shared with whatever renders the blocks, so boundaries agree. */
+    constructor(parse: (text: string) => Root);
+    /**
+     * Fold the current accumulated text and return the frozen/tail split.
+     * Idempotent for identical input (the previous result is returned as-is),
+     * so callers may invoke it from render paths that re-execute.
+     * @param text - The full accumulated markdown source.
+     * @returns Frozen and tail blocks with stream-stable render keys.
+     */
+    update(text: string): IncrementalBlocks;
+}
+//# sourceMappingURL=incremental.d.ts.map

package/lib/types/client/markdown/incremental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../../../src/client/markdown/incremental.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAS9C,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB;AAED,2DAA2D;AAC3D,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;IAC3C,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,SAAS,eAAe,EAAE,CAAA;IACzC,oGAAoG;IACpG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAeD;;;GAGG;AACH,qBAAa,yBAAyB;IAQxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAPlC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,MAAM,CAAiC;IAE/C,2FAA2F;gBAC9D,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;IAE1D;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB;CAsCxC"}

package/lib/types/client/markdown/incremental.js

@@ -0,0 +1,108 @@
+// Adapted from DeepSeek Harness b150a551b8d465e31e418e1b2eaf5e79bbb7d28e (MIT). See THIRD_PARTY_NOTICES.md.
+/**
+ * Incremental block-level markdown parsing for an append-only text stream.
+ *
+ * Re-parsing the whole accumulated document on every streaming chunk is
+ * quadratic in the final reply length. CommonMark block parsing is line-based
+ * and appended text can only reshape the parse frontier — the last top-level
+ * block (a paragraph becoming a setext heading or a table, a list continuing
+ * after a blank line, an unclosed fence swallowing lines) — so earlier blocks
+ * are final. This parser therefore freezes all but the trailing
+ * {@link UNSTABLE_TAIL_BLOCKS} blocks and re-parses only the source tail
+ * behind them: each source region is parsed O(1) times over the stream
+ * instead of once per chunk.
+ *
+ * The freeze boundary comes from the parser's own `position` offsets, never
+ * from custom source scanning. The cut sits at the *end offset* of the last
+ * frozen block (not the next block's start): a following block's start offset
+ * excludes up to three spaces of insignificant leading indentation, which is
+ * harmless to drop, but cutting at the previous end also keeps the
+ * inter-block blank lines in the tail so the sliced source stays verbatim.
+ *
+ * Known deviation, shared with any prefix-freeze scheme: micromark resolves
+ * reference-style links and footnotes document-wide at parse time, so a
+ * reference whose definition lands on the other side of the freeze boundary
+ * renders literally until the settled full parse self-heals it.
+ */
+/**
+ * Trailing blocks kept unstable. Appended text reshapes at most the last
+ * block; the second-to-last is retained as safety margin so a freeze decision
+ * never has to reason about the parse frontier.
+ */
+const UNSTABLE_TAIL_BLOCKS = 2;
+/**
+ * A block's render key: its absolute source start offset. A position-less
+ * node (a grammar is free to omit positions) falls back to a negative
+ * list-index key — unique within one update's tail, which is the only place
+ * the fallback can occur: freezing requires the cut block's position, so a
+ * position-less parse keeps every block in the tail (real grammars always
+ * stamp positions and never take this path).
+ */
+function blockKey(node, base, index) {
+    const offset = node.position?.start.offset;
+    return offset === undefined ? -(index + 1) : base + offset;
+}
+/**
+ * Append-only incremental parser over a caller-supplied grammar. One instance
+ * accumulates one streaming document; non-append input resets it.
+ */
+export class IncrementalMarkdownParser {
+    parse;
+    prevText = '';
+    tailStart = 0;
+    frozen = [];
+    generation = 0;
+    cached = null;
+    /** @param parse - Grammar shared with whatever renders the blocks, so boundaries agree. */
+    constructor(parse) {
+        this.parse = parse;
+    }
+    /**
+     * Fold the current accumulated text and return the frozen/tail split.
+     * Idempotent for identical input (the previous result is returned as-is),
+     * so callers may invoke it from render paths that re-execute.
+     * @param text - The full accumulated markdown source.
+     * @returns Frozen and tail blocks with stream-stable render keys.
+     */
+    update(text) {
+        if (this.cached !== null && text === this.prevText)
+            return this.cached;
+        // Deliberate O(prefix) memcmp per update: sound divergence detection has
+        // to verify the whole retained prefix, and startsWith compares bytes two
+        // orders of magnitude faster than parsing them — the cost this class
+        // exists to remove. Passing append/reset deltas instead would push
+        // append bookkeeping across the session-projection update boundary for a check
+        // that stays sub-millisecond at realistic reply sizes.
+        if (!text.startsWith(this.prevText)) {
+            this.prevText = '';
+            this.tailStart = 0;
+            this.frozen = [];
+            this.generation += 1;
+        }
+        this.prevText = text;
+        const base = this.tailStart;
+        const blocks = this.parse(text.slice(base)).children;
+        let firstUnstable = Math.max(0, blocks.length - UNSTABLE_TAIL_BLOCKS);
+        if (firstUnstable > 0) {
+            const cutEnd = blocks[firstUnstable - 1]?.position?.end.offset;
+            if (cutEnd === undefined) {
+                // A grammar that omits positions leaves nothing to cut at; keep the
+                // whole parse in the tail rather than guessing a boundary.
+                firstUnstable = 0;
+            }
+            else {
+                for (const node of blocks.slice(0, firstUnstable)) {
+                    this.frozen.push({ node, key: blockKey(node, base, this.frozen.length) });
+                }
+                this.tailStart = base + cutEnd;
+            }
+        }
+        const tail = blocks.slice(firstUnstable).map((node, index) => ({
+            node,
+            key: blockKey(node, base, index),
+        }));
+        this.cached = { frozen: [...this.frozen], tail, generation: this.generation };
+        return this.cached;
+    }
+}
+//# sourceMappingURL=incremental.js.map

package/lib/types/client/markdown/incremental.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.js","sourceRoot":"","sources":["../../../../src/client/markdown/incremental.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH;;;;GAIG;AACH,MAAM,oBAAoB,GAAG,CAAC,CAAA;AAwB9B;;;;;;;GAOG;AACH,SAAS,QAAQ,CAAC,IAAiB,EAAE,IAAY,EAAE,KAAa;IAC9D,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1C,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,MAAM,CAAA;AAC5D,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,yBAAyB;IAQP;IAPrB,QAAQ,GAAG,EAAE,CAAA;IACb,SAAS,GAAG,CAAC,CAAA;IACb,MAAM,GAAsB,EAAE,CAAA;IAC9B,UAAU,GAAG,CAAC,CAAA;IACd,MAAM,GAA6B,IAAI,CAAA;IAE/C,2FAA2F;IAC3F,YAA6B,KAA6B;QAA7B,UAAK,GAAL,KAAK,CAAwB;IAAG,CAAC;IAE9D;;;;;;OAMG;IACH,MAAM,CAAC,IAAY;QACjB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC,MAAM,CAAA;QACtE,yEAAyE;QACzE,yEAAyE;QACzE,qEAAqE;QACrE,mEAAmE;QACnE,+EAA+E;QAC/E,uDAAuD;QACvD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YACpC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAA;YAClB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAA;YAClB,IAAI,CAAC,MAAM,GAAG,EAAE,CAAA;YAChB,IAAI,CAAC,UAAU,IAAI,CAAC,CAAA;QACtB,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;QACpB,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAA;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAA;QACpD,IAAI,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,oBAAoB,CAAC,CAAA;QACrE,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,MAAM,CAAC,aAAa,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAA;YAC9D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,oEAAoE;gBACpE,2DAA2D;gBAC3D,aAAa,GAAG,CAAC,CAAA;YACnB,CAAC;iBAAM,CAAC;gBACN,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,EAAE,CAAC;oBAClD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;gBAC3E,CAAC;gBACD,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,MAAM,CAAA;YAChC,CAAC;QACH,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;YAC7D,IAAI;YACJ,GAAG,EAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC;SACjC,CAAC,CAAC,CAAA;QACH,IAAI,CAAC,MAAM,GAAG,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,CAAA;QAC7E,OAAO,IAAI,CAAC,MAAM,CAAA;IACpB,CAAC;CACF"}

package/lib/types/client/markdown/katex.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TeX-to-React via KaTeX, replicating the rehype-katex pipeline this renderer
+ * replaced: the same three-arm error chain (strict render, `strict: 'ignore'`
+ * retry, error span) and a DOM-identical element tree, so settled math keeps
+ * its exact markup. KaTeX emits an HTML string; the browser's own HTML parser
+ * (`DOMParser`, applying the spec's SVG/MathML foreign-content attribute
+ * adjustments KaTeX output relies on) turns it into a tree this module maps
+ * onto React elements — KaTeX output is a static span/MathML/SVG vocabulary
+ * with no raw user HTML, the same trust shiki's tree gets in CodeBlock.
+ *
+ * React 18 has no MathML support, so the `.katex-mathml` subtree's elements
+ * land in the HTML namespace — exactly as they did under the replaced
+ * hast-util-to-jsx-runtime pipeline. The visual arm is the `.katex-html`
+ * span tree; the MathML arm serves assistive technology, which reads it by
+ * tag name regardless of namespace.
+ */
+import type { ReactNode } from 'react';
+/**
+ * Render TeX source to React elements through KaTeX.
+ * @param value - The TeX source (math node value; fenced `math` blocks append
+ * their trailing newline to match the replaced pipeline's text extraction).
+ * @param displayMode - Display (block) versus inline rendering.
+ * @returns KaTeX's element tree, or the error span when the source does not
+ * parse (colored with KaTeX's stock `errorColor`, matching rehype-katex).
+ */
+export declare function renderTexToReact(value: string, displayMode: boolean): ReactNode;
+//# sourceMappingURL=katex.d.ts.map

package/lib/types/client/markdown/katex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"katex.d.ts","sourceRoot":"","sources":["../../../../src/client/markdown/katex.tsx"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAA;AAuCrD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,SAAS,CAwB/E"}

package/lib/types/client/markdown/katex.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Adapted from DeepSeek Harness b150a551b8d465e31e418e1b2eaf5e79bbb7d28e (MIT). See THIRD_PARTY_NOTICES.md.
+/**
+ * TeX-to-React via KaTeX, replicating the rehype-katex pipeline this renderer
+ * replaced: the same three-arm error chain (strict render, `strict: 'ignore'`
+ * retry, error span) and a DOM-identical element tree, so settled math keeps
+ * its exact markup. KaTeX emits an HTML string; the browser's own HTML parser
+ * (`DOMParser`, applying the spec's SVG/MathML foreign-content attribute
+ * adjustments KaTeX output relies on) turns it into a tree this module maps
+ * onto React elements — KaTeX output is a static span/MathML/SVG vocabulary
+ * with no raw user HTML, the same trust shiki's tree gets in CodeBlock.
+ *
+ * React 18 has no MathML support, so the `.katex-mathml` subtree's elements
+ * land in the HTML namespace — exactly as they did under the replaced
+ * hast-util-to-jsx-runtime pipeline. The visual arm is the `.katex-html`
+ * span tree; the MathML arm serves assistive technology, which reads it by
+ * tag name regardless of namespace.
+ */
+import { createElement } from 'react';
+import katex from 'katex';
+/**
+ * Convert one inline `style` attribute string into React's style object.
+ * KaTeX emits only plain kebab-case declarations (no custom properties and no
+ * nameless declarations), so camel-casing the property is the whole mapping.
+ */
+function styleObject(css) {
+    const style = {};
+    for (const declaration of css.split(';')) {
+        const colon = declaration.indexOf(':');
+        if (colon === -1)
+            continue;
+        const name = declaration.slice(0, colon).trim();
+        const key = name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        style[key] = declaration.slice(colon + 1).trim();
+    }
+    return style;
+}
+/** Map one parsed DOM node onto a React element (text nodes pass through). */
+function domToReact(node, key) {
+    if (node.nodeType === Node.TEXT_NODE)
+        return node.textContent;
+    /* v8 ignore next 2 -- KaTeX output holds only elements and text; other
+       node kinds cannot appear in its serialized vocabulary. */
+    if (node.nodeType !== Node.ELEMENT_NODE)
+        return null;
+    const element = node;
+    const props = { key };
+    for (const attribute of element.attributes) {
+        if (attribute.name === 'class')
+            props['className'] = attribute.value;
+        else if (attribute.name === 'style')
+            props['style'] = styleObject(attribute.value);
+        else
+            props[attribute.name] = attribute.value;
+    }
+    const children = [...element.childNodes].map(domToReact);
+    return children.length === 0
+        ? createElement(element.localName, props)
+        : createElement(element.localName, props, ...children);
+}
+/**
+ * Render TeX source to React elements through KaTeX.
+ * @param value - The TeX source (math node value; fenced `math` blocks append
+ * their trailing newline to match the replaced pipeline's text extraction).
+ * @param displayMode - Display (block) versus inline rendering.
+ * @returns KaTeX's element tree, or the error span when the source does not
+ * parse (colored with KaTeX's stock `errorColor`, matching rehype-katex).
+ */
+export function renderTexToReact(value, displayMode) {
+    let html;
+    try {
+        html = katex.renderToString(value, { displayMode, throwOnError: true });
+    }
+    catch (error) {
+        try {
+            html = katex.renderToString(value, { displayMode, strict: 'ignore', throwOnError: false });
+        }
+        catch {
+            // KaTeX renders ParseErrors itself under throwOnError: false; only its
+            // internal errors reach here, so mirror rehype-katex's manual span.
+            /* v8 ignore next 8 */
+            return (_jsx("span", { className: "katex-error", style: { color: '#cc0000' }, title: String(error), children: value }));
+        }
+    }
+    const parsed = new DOMParser().parseFromString(html, 'text/html');
+    return [...parsed.body.childNodes].map(domToReact);
+}
+//# sourceMappingURL=katex.js.map

package/lib/types/client/markdown/katex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"katex.js","sourceRoot":"","sources":["../../../../src/client/markdown/katex.tsx"],"names":[],"mappings":"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"}

package/lib/types/client/markdown/mathCompatibility.d.ts

@@ -0,0 +1,11 @@
+/** Extend upstream dollar-only math syntax with TeX delimiters while reusing its token vocabulary. */
+import type { Extension } from 'micromark-util-types';
+/**
+ * TeX backslash delimiters and same-line display-dollar blocks as a micromark
+ * syntax extension reusing `micromark-extension-math`'s token vocabulary; the
+ * caller must also register `math()` on the same parse so the emitted tokens
+ * compile to standard math nodes.
+ * @returns The micromark syntax extension.
+ */
+export declare function mathCompatibility(): Extension;
+//# sourceMappingURL=mathCompatibility.d.ts.map

package/lib/types/client/markdown/mathCompatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathCompatibility.d.ts","sourceRoot":"","sources":["../../../../src/client/markdown/mathCompatibility.ts"],"names":[],"mappings":"AACA,sGAAsG;AAMtG,OAAO,KAAK,EAAa,SAAS,EAA8B,MAAM,sBAAsB,CAAA;AA6U5F;;;;;;GAMG;AACH,wBAAgB,iBAAiB,IAAI,SAAS,CAE7C"}