@lofcz/streamdown 2.9.1 → 2.9.2

package/dist/lib/block-incomplete-context.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Context that indicates whether the current block has an incomplete code fence.
+ * True when: streaming is active AND this is the last block AND it has an unclosed code fence.
+ */
+declare const BlockIncompleteContext: import("react").Context<boolean>;
+/**
+ * Hook to check if the current block has an incomplete (unclosed) code fence.
+ *
+ * Returns `true` when the code fence in this block is still being streamed.
+ * Useful for deferring expensive renders (syntax highlighting, Mermaid diagrams)
+ * until the code block is complete.
+ */
+export declare const useIsCodeFenceIncomplete: () => boolean;
+export { BlockIncompleteContext };

package/dist/lib/code-block/body.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentProps } from "react";
+import type { HighlightResult } from "../plugin-types";
+type CodeBlockBodyProps = ComponentProps<"div"> & {
+    maxHeight?: number | string;
+    result: HighlightResult;
+    language: string;
+    startLine?: number;
+    /** Show line numbers in code blocks. @default true */
+    lineNumbers?: boolean;
+};
+export declare const CodeBlockBody: import("react").MemoExoticComponent<({ children, result, language, className, maxHeight, startLine, lineNumbers, ...rest }: CodeBlockBodyProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/lib/code-block/container.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps } from "react";
+type CodeBlockContainerProps = ComponentProps<"div"> & {
+    language: string;
+    /** Whether the code block is still being streamed (incomplete) */
+    isIncomplete?: boolean;
+};
+export declare const CodeBlockContainer: ({ className, language, style, isIncomplete, ...props }: CodeBlockContainerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/code-block/context.d.ts

@@ -0,0 +1,6 @@
+interface CodeBlockContextType {
+    code: string;
+}
+export declare const CodeBlockContext: import("react").Context<CodeBlockContextType>;
+export declare const useCodeBlockContext: () => CodeBlockContextType;
+export {};

package/dist/lib/code-block/copy-button.d.ts

@@ -0,0 +1,9 @@
+import { type ComponentProps } from "react";
+export type CodeBlockCopyButtonProps = ComponentProps<"button"> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const CodeBlockCopyButton: ({ onCopy, onError, timeout, children, className, code: propCode, ...props }: CodeBlockCopyButtonProps & {
+    code?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/code-block/download-button.d.ts

@@ -0,0 +1,9 @@
+import { type ComponentProps } from "react";
+export type CodeBlockDownloadButtonProps = ComponentProps<"button"> & {
+    onDownload?: () => void;
+    onError?: (error: Error) => void;
+};
+export declare const CodeBlockDownloadButton: ({ onDownload, onError, language, children, className, code: propCode, ...props }: CodeBlockDownloadButtonProps & {
+    code?: string;
+    language?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/code-block/header.d.ts

@@ -0,0 +1,5 @@
+interface CodeBlockHeaderProps {
+    language: string;
+}
+export declare const CodeBlockHeader: ({ language }: CodeBlockHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/code-block/highlighted-body.d.ts

@@ -0,0 +1,12 @@
+import { type HTMLAttributes } from "react";
+import type { HighlightResult } from "../plugin-types";
+type HighlightedCodeBlockBodyProps = HTMLAttributes<HTMLDivElement> & {
+    code: string;
+    language: string;
+    maxHeight?: number | string;
+    raw: HighlightResult;
+    startLine?: number;
+    lineNumbers?: boolean;
+};
+export declare const HighlightedCodeBlockBody: ({ code, language, maxHeight, raw, className, startLine, lineNumbers, ...rest }: HighlightedCodeBlockBodyProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/code-block/index.d.ts

@@ -0,0 +1,13 @@
+import { type HTMLAttributes } from "react";
+type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
+    code: string;
+    language: string;
+    /** Whether the code block is still being streamed (incomplete) */
+    isIncomplete?: boolean;
+    /** Custom starting line number for line numbering (default: 1) */
+    startLine?: number;
+    /** Show line numbers in code blocks. @default true */
+    lineNumbers?: boolean;
+};
+export declare const CodeBlock: ({ code, language, className, children, isIncomplete, startLine, lineNumbers, ...rest }: CodeBlockProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/code-block/skeleton.d.ts

@@ -0,0 +1 @@
+export declare const CodeBlockSkeleton: () => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components.d.ts

@@ -0,0 +1,2 @@
+import type { Options } from "./markdown";
+export declare const components: Options["components"];

package/dist/lib/detect-direction.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Detect text direction using the "first strong character" algorithm.
+ * Strips common markdown syntax then finds the first Unicode letter
+ * with strong directionality.
+ *
+ * Note: markdown stripping is best-effort — nested formatting,
+ * multi-line fenced code blocks, and raw HTML are not fully handled.
+ * This is acceptable since the algorithm only needs to reach the first
+ * strong character, which is almost always in plain prose.
+ *
+ * @returns "rtl" if first strong char is RTL, "ltr" otherwise
+ */
+export declare function detectTextDirection(text: string): "ltr" | "rtl";

package/dist/lib/icon-context.d.ts

@@ -0,0 +1,23 @@
+import { type SVGProps } from "react";
+export type IconComponent = React.ComponentType<SVGProps<SVGSVGElement> & {
+    size?: number;
+}>;
+export interface IconMap {
+    CheckIcon: IconComponent;
+    CopyIcon: IconComponent;
+    DownloadIcon: IconComponent;
+    ExternalLinkIcon: IconComponent;
+    Loader2Icon: IconComponent;
+    Maximize2Icon: IconComponent;
+    RotateCcwIcon: IconComponent;
+    XIcon: IconComponent;
+    ZoomInIcon: IconComponent;
+    ZoomOutIcon: IconComponent;
+}
+export declare const defaultIcons: IconMap;
+export declare const IconContext: import("react").Context<IconMap>;
+export declare const IconProvider: ({ icons, children, }: {
+    icons?: Partial<IconMap>;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useIcons: () => IconMap;

package/dist/lib/icons.d.ts

@@ -0,0 +1,14 @@
+/** biome-ignore-all lint/a11y/noSvgWithoutTitle: "Streamdown icons" */
+import type { SVGProps } from "react";
+type IconProps = SVGProps<SVGSVGElement>;
+export declare const CheckIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CopyIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DownloadIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Loader2Icon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Maximize2Icon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const RotateCcwIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const XIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ExternalLinkIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ZoomInIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ZoomOutIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/image.d.ts

@@ -0,0 +1,5 @@
+import type { DetailedHTMLProps, ImgHTMLAttributes } from "react";
+import type { ExtraProps } from "./markdown";
+type ImageComponentProps = DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement> & ExtraProps;
+export declare const ImageComponent: ({ node: _node, className, src, alt, onLoad: onLoadProp, onError: onErrorProp, onClick: onClickProp, ...props }: ImageComponentProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/lib/incomplete-code-utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Checks if a markdown string contains an incomplete (unclosed) code fence
+ * by walking line-by-line per the CommonMark spec.
+ *
+ * Only counts fences that start at the beginning of a line (with up to 3
+ * spaces of indentation). This avoids false positives from inline backticks
+ * and correctly handles fences of any length (3+).
+ *
+ * A closing fence must use the same character as the opening fence and be
+ * at least as long.
+ *
+ * @param markdown - The markdown string to check
+ * @returns true if there's an unclosed code fence
+ */
+export declare const hasIncompleteCodeFence: (markdown: string) => boolean;
+/**
+ * Checks if a markdown block contains a GFM table by looking for a
+ * delimiter row (e.g., `| --- | --- |`). A delimiter row confirms that
+ * the preceding header row forms a table.
+ *
+ * @param markdown - The markdown string to check
+ * @returns true if the block contains a table
+ */
+export declare const hasTable: (markdown: string) => boolean;

package/dist/lib/link-modal.d.ts

@@ -0,0 +1,8 @@
+interface LinkSafetyModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    url: string;
+}
+export declare const LinkSafetyModal: ({ url, isOpen, onClose, onConfirm, }: LinkSafetyModalProps) => import("react").ReactPortal | null;
+export {};

package/dist/lib/markdown.d.ts

@@ -0,0 +1,30 @@
+import type { Element, Parents } from "hast";
+import type { ComponentType, JSX, ReactElement } from "react";
+import type { Options as RemarkRehypeOptions } from "remark-rehype";
+import type { PluggableList } from "unified";
+export interface ExtraProps {
+    node?: Element | undefined;
+}
+export type AllowElement = (element: Readonly<Element>, index: number, parent: Readonly<Parents> | undefined) => boolean | null | undefined;
+export type UrlTransform = (url: string, key: string, node: Readonly<Element>) => string | null | undefined;
+export type Components = {
+    [Key in keyof JSX.IntrinsicElements]?: ComponentType<JSX.IntrinsicElements[Key] & ExtraProps> | keyof JSX.IntrinsicElements;
+} & {
+    inlineCode?: ComponentType<JSX.IntrinsicElements["code"] & ExtraProps>;
+    [key: string]: ComponentType<Record<string, unknown> & ExtraProps> | keyof JSX.IntrinsicElements | undefined;
+};
+export interface Options {
+    allowElement?: AllowElement;
+    allowedElements?: readonly string[];
+    children?: string;
+    components?: Components;
+    disallowedElements?: readonly string[];
+    rehypePlugins?: PluggableList;
+    remarkPlugins?: PluggableList;
+    remarkRehypeOptions?: Readonly<RemarkRehypeOptions>;
+    skipHtml?: boolean;
+    unwrapDisallowed?: boolean;
+    urlTransform?: UrlTransform;
+}
+export declare const Markdown: (options: Readonly<Options>) => ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export declare const defaultUrlTransform: UrlTransform;

package/dist/lib/mermaid/download-button.d.ts

@@ -0,0 +1,11 @@
+import type { MermaidConfig } from "../plugin-types";
+interface MermaidDownloadDropdownProps {
+    chart: string;
+    children?: React.ReactNode;
+    className?: string;
+    config?: MermaidConfig;
+    onDownload?: (format: "mmd" | "png" | "svg") => void;
+    onError?: (error: Error) => void;
+}
+export declare const MermaidDownloadDropdown: ({ chart, children, className, onDownload, config, onError, }: MermaidDownloadDropdownProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/mermaid/fullscreen-button.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentProps } from "react";
+import type { MermaidConfig } from "../plugin-types";
+type MermaidFullscreenButtonProps = ComponentProps<"button"> & {
+    chart: string;
+    config?: MermaidConfig;
+    onFullscreen?: () => void;
+    onExit?: () => void;
+};
+export declare const MermaidFullscreenButton: ({ chart, config, onFullscreen, onExit, className, ...props }: MermaidFullscreenButtonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/mermaid/index.d.ts

@@ -0,0 +1,10 @@
+import type { MermaidConfig } from "../plugin-types";
+interface MermaidProps {
+    chart: string;
+    className?: string;
+    config?: MermaidConfig;
+    fullscreen?: boolean;
+    showControls?: boolean;
+}
+export declare const Mermaid: ({ chart, className, config, fullscreen, showControls, }: MermaidProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/mermaid/pan-zoom.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from "react";
+interface PanZoomProps {
+    children: ReactNode;
+    className?: string;
+    contentSize?: {
+        height: number;
+        width: number;
+    } | null;
+    fitKey?: string;
+    fullscreen?: boolean;
+    initialZoom?: number;
+    isAutoFit?: boolean;
+    maxZoom?: number;
+    minZoom?: number;
+    showControls?: boolean;
+    zoomStep?: number;
+}
+export declare const PanZoom: ({ children, className, contentSize, fitKey: _fitKey, minZoom, maxZoom, zoomStep, showControls, initialZoom, isAutoFit, fullscreen, }: PanZoomProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/mermaid/utils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Ensure the SVG root element declares the xlink namespace when the document
+ * contains xlink-prefixed attributes (e.g. `xlink:href` used by Mermaid in
+ * C4 and sequence diagrams).  Without the declaration the SVG is not valid
+ * XML: browsers refuse to load it as an image, causing PNG export to fail
+ * silently.
+ *
+ * The fix mirrors the approach used for other Mermaid SVG normalisation
+ * issues: detect the problem via a lightweight string check and patch the
+ * root `<svg>` opening tag in-place before any further processing.
+ *
+ * Falls back to the original string when the namespace is already present or
+ * when xlink-prefixed attributes are absent.
+ */
+export declare const addXlinkNamespaceIfMissing: (svgString: string) => string;
+/**
+ * Mermaid render output may be HTML-serialized. Serialize the SVG node as XML
+ * before downloading so embedded HTML like <br> becomes valid SVG markup.
+ */
+export declare const serializeSvgForDownload: (svgString: string) => string;
+/**
+ * Normalize Mermaid SVG dimensions for inline rendering.
+ * Mermaid emits width="100%" with max-width style, which can shrink very wide
+ * diagrams until text becomes unreadable.
+ */
+export declare const getMermaidSvgSize: (svgString: string) => {
+    height: number;
+    width: number;
+} | null;
+/**
+ * Normalize Mermaid SVG dimensions for inline rendering.
+ * Mermaid emits width="100%" with max-width style, which can shrink very wide
+ * diagrams until text becomes unreadable.
+ */
+export declare const normalizeMermaidInlineSvg: (svgString: string) => string;
+/**
+ * Convert SVG string to PNG blob for export
+ */
+export declare const svgToPngBlob: (svgString: string, options?: {
+    scale?: number;
+}) => Promise<Blob>;

package/dist/lib/parse-blocks.d.ts

@@ -0,0 +1,12 @@
+export declare const parseMarkdownIntoBlocks: (markdown: string) => string[];
+export interface IncrementalParseState {
+    blocks: string[];
+    /** Tag-preprocessed markdown that produced `blocks` (before last-block remend). */
+    source: string;
+}
+/**
+ * Append-only parse for streaming: keep settled prefix blocks by identity and
+ * only re-lex the unfinished tail. Falls back to a full parse when the source
+ * is not a pure append (edits, rewinds, or structural shifts).
+ */
+export declare const parseMarkdownIntoBlocksIncremental: (markdown: string, prev: IncrementalParseState | null | undefined, parseFn?: (value: string) => string[]) => IncrementalParseState;

package/dist/lib/plugin-context.d.ts

@@ -0,0 +1,29 @@
+import type { PluginConfig } from "./plugin-types";
+/**
+ * Context for Streamdown plugins
+ */
+export declare const PluginContext: import("react").Context<PluginConfig | null>;
+/**
+ * Hook to access all plugins
+ */
+export declare const usePlugins: () => PluginConfig | null;
+/**
+ * Hook to access the code plugin
+ */
+export declare const useCodePlugin: () => import("./plugin-types").CodeHighlighterPlugin | null;
+/**
+ * Hook to access the mermaid plugin
+ */
+export declare const useMermaidPlugin: () => import("./plugin-types").DiagramPlugin | null;
+/**
+ * Hook to access the math plugin
+ */
+export declare const useMathPlugin: () => import("./plugin-types").MathPlugin | null;
+/**
+ * Hook to access the cjk plugin
+ */
+export declare const useCjkPlugin: () => import("./plugin-types").CjkPlugin | null;
+/**
+ * Hook to find a custom renderer for a given language
+ */
+export declare const useCustomRenderer: (language: string) => import("./plugin-types").CustomRenderer | null;

package/dist/lib/plugin-types.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Structural type for Mermaid configuration.
+ * Avoids a hard dependency on the "mermaid" package in the core bundle.
+ * Users who need full type safety can import MermaidConfig from "mermaid"
+ * directly — it is structurally compatible with this type.
+ */
+export type MermaidConfig = Record<string, any>;
+import type React from "react";
+import type { BundledLanguage, BundledTheme, ThemeRegistrationAny } from "shiki";
+import type { Pluggable } from "unified";
+export type ThemeInput = BundledTheme | ThemeRegistrationAny;
+/**
+ * A single token in a highlighted line
+ */
+export interface HighlightToken {
+    bgColor?: string;
+    color?: string;
+    content: string;
+    htmlAttrs?: Record<string, string>;
+    htmlStyle?: Record<string, string>;
+    offset?: number;
+}
+/**
+ * Result from code highlighting (compatible with shiki's TokensResult)
+ */
+export interface HighlightResult {
+    bg?: string;
+    fg?: string;
+    rootStyle?: string | false;
+    tokens: HighlightToken[][];
+}
+/**
+ * Options for highlighting code
+ */
+export interface HighlightOptions {
+    code: string;
+    language: BundledLanguage;
+    themes: [ThemeInput, ThemeInput];
+}
+/**
+ * Plugin for code syntax highlighting (Shiki)
+ */
+export interface CodeHighlighterPlugin {
+    /**
+     * Get list of supported languages
+     */
+    getSupportedLanguages: () => BundledLanguage[];
+    /**
+     * Get the configured themes
+     */
+    getThemes: () => [ThemeInput, ThemeInput];
+    /**
+     * Highlight code and return tokens
+     * Returns null if highlighting not ready yet (async loading)
+     * Use callback for async result
+     */
+    highlight: (options: HighlightOptions, callback?: (result: HighlightResult) => void) => HighlightResult | null;
+    name: "shiki";
+    /**
+     * Check if language is supported
+     */
+    supportsLanguage: (language: BundledLanguage) => boolean;
+    type: "code-highlighter";
+}
+/**
+ * Mermaid instance interface
+ */
+export interface MermaidInstance {
+    initialize: (config: MermaidConfig) => void;
+    render: (id: string, source: string) => Promise<{
+        svg: string;
+    }>;
+}
+/**
+ * Plugin for diagram rendering (Mermaid)
+ */
+export interface DiagramPlugin {
+    /**
+     * Get the mermaid instance (initialized with optional config)
+     */
+    getMermaid: (config?: MermaidConfig) => MermaidInstance;
+    /**
+     * Language identifier for code blocks
+     */
+    language: string;
+    name: "mermaid";
+    type: "diagram";
+}
+/**
+ * Plugin for math rendering (KaTeX)
+ */
+export interface MathPlugin {
+    /**
+     * Get CSS styles for math rendering (injected into head)
+     */
+    getStyles?: () => string;
+    name: "katex";
+    /**
+     * Get rehype plugin for rendering math
+     */
+    rehypePlugin: Pluggable;
+    /**
+     * Get remark plugin for parsing math syntax
+     */
+    remarkPlugin: Pluggable;
+    type: "math";
+}
+/**
+ * Plugin for CJK text handling
+ */
+export interface CjkPlugin {
+    name: "cjk";
+    /**
+     * @deprecated Use remarkPluginsBefore and remarkPluginsAfter instead
+     * All remark plugins (for backwards compatibility)
+     */
+    remarkPlugins: Pluggable[];
+    /**
+     * Remark plugins that must run AFTER remarkGfm
+     * (e.g., autolink boundary splitting, strikethrough enhancements)
+     */
+    remarkPluginsAfter: Pluggable[];
+    /**
+     * Remark plugins that must run BEFORE remarkGfm
+     * (e.g., remark-cjk-friendly which modifies emphasis handling)
+     */
+    remarkPluginsBefore: Pluggable[];
+    type: "cjk";
+}
+/**
+ * Union type for all plugins
+ */
+export type StreamdownPlugin = CodeHighlighterPlugin | DiagramPlugin | MathPlugin | CjkPlugin;
+export interface CustomRendererProps {
+    code: string;
+    isIncomplete: boolean;
+    language: string;
+    /** Raw metastring from the code fence (everything after the language identifier).
+     * e.g. ```rust {1} title="foo"  →  meta = '{1} title="foo"'
+     * Undefined when no metastring is present. */
+    meta?: string;
+}
+export interface CustomRenderer {
+    component: React.ComponentType<CustomRendererProps>;
+    language: string | string[];
+}
+/**
+ * Plugin configuration passed to Streamdown
+ */
+export interface PluginConfig {
+    cjk?: CjkPlugin;
+    code?: CodeHighlighterPlugin;
+    math?: MathPlugin;
+    mermaid?: DiagramPlugin;
+    renderers?: CustomRenderer[];
+}

package/dist/lib/prefix-context.d.ts

@@ -0,0 +1,12 @@
+import { type CnFunction } from "./utils";
+/**
+ * Context for providing a prefix-aware `cn` function to all components.
+ * Defaults to the standard `cn` (no prefix) for zero-overhead when unused.
+ */
+export declare const PrefixContext: import("react").Context<CnFunction>;
+/**
+ * Hook to access the prefix-aware `cn` function.
+ * When a prefix is set via `<Streamdown prefix="...">`, this returns
+ * a `cn` that prepends the prefix to all class names.
+ */
+export declare const useCn: () => CnFunction;

package/dist/lib/preprocess-custom-tags.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Preprocesses markdown to prevent custom tag blocks from being broken apart
+ * by the CommonMark parser. Two issues are addressed:
+ *
+ * 1. **Inline content after opening tag**: In CommonMark, HTML block types 6/7
+ *    require the opening tag to start a line on its own (or be followed only by
+ *    whitespace). When content appears on the same line as the opening tag
+ *    (e.g. `<custom>content`), the parser treats it as inline HTML inside a
+ *    paragraph instead of an HTML block, causing the tag to lose its structure.
+ *    This function ensures the opening tag, content, and closing tag each
+ *    occupy their own lines.
+ *
+ * 2. **Blank lines inside tag content**: HTML blocks end at blank lines, which
+ *    causes custom tags with blank lines in their content to be split across
+ *    multiple tokens. This function replaces blank lines within matched custom
+ *    tag pairs with HTML comments (`<!---->`), so the markdown parser treats
+ *    the entire tag block as a single unit.
+ */
+export declare const preprocessCustomTags: (markdown: string, tagNames: string[]) => string;

package/dist/lib/preprocess-literal-tag-content.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Escapes markdown metacharacters inside the content of specified custom tags,
+ * so that markdown inside those tags is rendered as plain text rather than
+ * being interpreted as formatting.
+ *
+ * This must run BEFORE the markdown parser sees the string, because by the time
+ * rehype plugins execute the markdown has already been parsed and structural
+ * information (e.g. underscores around emphasis) is lost.
+ *
+ * Note: content that already contains backslash escapes (e.g. `\_`) will be
+ * double-escaped and render with a visible backslash. This is acceptable since
+ * the intended use case is raw data labels (usernames, handles) that should
+ * not contain markdown escape sequences.
+ *
+ * Example:
+ *   Input:  `<mention user_id="123">_some_username_</mention>`
+ *   Output: `<mention user_id="123">\_some\_username\_</mention>`
+ *   Rendered: literal `_some_username_`
+ */
+/**
+ * For each tag in `tagNames`, escapes markdown metacharacters inside the tag's
+ * content so that the parser treats the children as plain text.
+ */
+export declare const preprocessLiteralTagContent: (markdown: string, tagNames: string[]) => string;

package/dist/lib/rehype/literal-tag-content.d.ts

@@ -0,0 +1,12 @@
+import type { Root } from "hast";
+import type { Plugin } from "unified";
+/**
+ * rehype plugin — replaces children of elements whose tag names are in
+ * `tagNames` with a single plain-text node. Run this after rehype-raw and
+ * rehype-sanitize so the custom elements already exist as proper HAST nodes.
+ *
+ * Works in tandem with `preprocessLiteralTagContent`, which escapes markdown
+ * syntax before remark parses it, ensuring the text value here reflects the
+ * original literal content (not stripped markdown markers).
+ */
+export declare const rehypeLiteralTagContent: Plugin<[string[]], Root>;

package/dist/lib/rehype/markdown-in-custom-tags.d.ts

@@ -0,0 +1,16 @@
+/**
+ * rehype plugin — re-parses text content of custom tag elements as Markdown.
+ *
+ * When a custom tag contains multiline content (e.g. `<ai-thinking>\n**bold**</ai-thinking>`),
+ * the CommonMark parser treats the entire block as an HTML block, passing the
+ * inner content through as raw text rather than parsing it as Markdown. This
+ * plugin corrects that by finding affected elements and replacing their
+ * text-only children with a proper Markdown-parsed HAST subtree.
+ *
+ * Runs after rehype-raw and rehype-sanitize so that custom elements already
+ * exist as proper HAST nodes. Must NOT be applied to tags listed in
+ * `literalTagContent` (those intentionally suppress Markdown parsing).
+ */
+import type { Root } from "hast";
+import type { Plugin } from "unified";
+export declare const rehypeMarkdownInCustomTags: Plugin<[string[], string[]?], Root>;

package/dist/lib/remark/code-meta.d.ts

@@ -0,0 +1,9 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+/**
+ * Remark plugin that forwards code fence meta strings to hast properties.
+ * This makes the meta string available as a `metastring` prop to the custom
+ * code component, enabling features like custom starting line numbers
+ * (e.g. `startLine=10`).
+ */
+export declare const remarkCodeMeta: Plugin<[], Root>;