@stream-mdx/react 0.4.0 → 1.0.0

package/dist/index-Cmne1yUK.d.cts

@@ -0,0 +1,723 @@
+import './components/bottom-stick-scroll-area.cjs';
+import './components/diff-renderer.cjs';
+import React__default, { JSXElementConstructor, Key, ReactNode, ReactElement } from 'react';
+import { BlockResolvedLinkReference, CodeNodeHandle, TableNodeHandle, InlineNode, Block, LazyTokenizationPriority, ContentPolicy, FormatAnticipationConfig, CodeHighlightingMode, CodeHighlightOutputMode, SyntaxExtensionDescriptor, HtmlOptions, InlineHtmlDescriptor, UrlTransform, HtmlTreeNode, MixedContentSegment } from '@stream-mdx/core';
+import { FinalizeResult } from '@stream-mdx/protocol';
+import { a as TrustedMdxEngine } from './trusted-mdx-contract-ElKpkDI5.cjs';
+import { CodeEngine } from '@stream-mdx/worker/engine';
+import { VirtualizedCodeConfig } from './renderer/virtualized-code.cjs';
+
+type ContentComponentProps = Readonly<Record<string, unknown>>;
+interface ContentComponentHostProps {
+    readonly key?: Key;
+    readonly children?: ReactNode;
+    readonly "data-diagnostic"?: string;
+    readonly "data-component-status"?: string;
+}
+interface ContentComponentRenderInput {
+    readonly props: ContentComponentProps;
+    readonly key: Key;
+    readonly hasChildren: boolean;
+    readonly renderChildren: () => ReactNode;
+    readonly status: "open" | "closed" | "incomplete";
+    readonly diagnostic?: string | undefined;
+}
+type ContentComponentRenderResult = {
+    readonly kind: "invalid";
+} | {
+    readonly kind: "suppressed";
+} | {
+    readonly kind: "rendered";
+    readonly element: ReactElement;
+};
+type ContentComponentRenderAdapter = (input: ContentComponentRenderInput) => ContentComponentRenderResult;
+interface ContentComponentRegistration {
+    readonly render: ContentComponentRenderAdapter;
+    readonly renderWhen: "open" | "closed";
+}
+type ContentComponentsMap = Readonly<Record<string, ContentComponentRegistration>>;
+type ContentComponentPropsGuard<P extends object> = (props: ContentComponentProps) => props is ContentComponentProps & P;
+interface ValidatedContentComponentOptions<P extends object> {
+    readonly component: JSXElementConstructor<P & ContentComponentHostProps>;
+    readonly validateProps: ContentComponentPropsGuard<P>;
+    readonly renderWhen?: "open" | "closed";
+}
+interface BroadContentComponentOptions {
+    readonly component: JSXElementConstructor<ContentComponentProps & ContentComponentHostProps>;
+    readonly validateProps?: undefined;
+    readonly renderWhen?: "open" | "closed";
+}
+/**
+ * Binds a typed host component to restricted source props. The returned adapter
+ * retains the component type privately and exposes only the validated render seam.
+ */
+declare function defineContentComponent<P extends object>(options: ValidatedContentComponentOptions<P>): ContentComponentRegistration;
+declare function defineContentComponent(options: BroadContentComponentOptions): ContentComponentRegistration;
+
+interface TableVirtualizationConfig {
+    /** Enables opt-in table row virtualization. */
+    enabled: boolean;
+    /** Minimum body row count. Default: 40. */
+    minRows: number;
+    /** Alias for minRows. */
+    virtualizeThreshold?: number;
+    /** Height in pixels used until a row is measured. Default: 40. */
+    estimatedRowHeight: number;
+    /** Buffer rows on each side of the viewport, bounded to 1–50. Default: 8. */
+    overscan: number;
+    /** Scroll container maximum height. Default: "600px". */
+    maxHeight: number | string;
+}
+type TableVirtualizationOptions = boolean | Partial<TableVirtualizationConfig>;
+declare const DEFAULT_TABLE_VIRTUALIZATION_CONFIG: TableVirtualizationConfig;
+
+type TableDownloadFormat = "csv" | "tsv" | "markdown";
+type TableCopyFormat = "tsv" | "markdown";
+interface CodeControlsConfig {
+    copy?: boolean;
+    download?: boolean;
+}
+interface TableControlsConfig {
+    copy?: boolean | TableCopyFormat[];
+    download?: boolean | TableDownloadFormat[];
+}
+interface MermaidControlsConfig {
+    copy?: boolean;
+    fullscreen?: boolean;
+}
+interface ControlsLabels {
+    copy?: string;
+    copied?: string;
+    copyError?: string;
+    download?: string;
+    downloadCsv?: string;
+    downloadTsv?: string;
+    downloadMarkdown?: string;
+    copyTsv?: string;
+    copyMarkdown?: string;
+    copyTable?: string;
+    fullscreen?: string;
+    exitFullscreen?: string;
+    [key: string]: string | undefined;
+}
+interface ControlsOptions {
+    code?: boolean | CodeControlsConfig;
+    table?: boolean | TableControlsConfig;
+    mermaid?: boolean | MermaidControlsConfig;
+    labels?: ControlsLabels;
+}
+type ControlsConfig = boolean | ControlsOptions;
+interface ControlsComponentProps {
+    type: "code" | "table" | "mermaid";
+    blockId?: string;
+    isFinalized?: boolean;
+    code?: string;
+    language?: string;
+    headers?: string[];
+    rows?: string[][];
+    align?: Array<"left" | "center" | "right" | null>;
+    /** Materialize table strings only when a custom control action needs them. */
+    getTableData?: () => {
+        headers: string[];
+        rows: string[][];
+        align?: Array<"left" | "center" | "right" | null>;
+    };
+    onCopy?: (format?: "raw" | "tsv" | "markdown") => Promise<boolean> | boolean | void;
+    onDownload?: (format?: "code" | "csv" | "tsv" | "markdown") => void;
+    labels?: ControlsLabels;
+    children?: React__default.ReactNode;
+}
+interface ElementFilterDescriptor {
+    tagName: string;
+    properties: Record<string, unknown>;
+    blockType?: string;
+}
+interface ElementFilterContext {
+    source: "markdown" | "html";
+    parentTagName?: string;
+}
+type AllowElementFn = (element: ElementFilterDescriptor, context: ElementFilterContext) => boolean;
+/** Render-time element filtering, matching react-markdown / Streamdown semantics. */
+interface ElementFilterOptions {
+    /** Only these tag names render. Mutually exclusive with `disallowedElements`. */
+    allowedElements?: string[];
+    /** These tag names never render. Mutually exclusive with `allowedElements`. */
+    disallowedElements?: string[];
+    /** Final per-element predicate; runs after the allow/deny lists. */
+    allowElement?: AllowElementFn;
+    /** Render the children of removed elements in place instead of dropping the subtree. */
+    unwrapDisallowed?: boolean;
+    /** Autolink protocols (e.g. `["mailto"]`) whose bare/angle autolinks render as plain text. Explicit links are unaffected. */
+    disableAutolinkProtocols?: string[];
+}
+/** Math rendering policy. Expressions are isolated unless a document scope is explicitly selected. */
+interface MathOptions {
+    macroScope?: "document";
+}
+type GenericComponent = React__default.ComponentType<any>;
+interface TableElements {
+    Table: GenericComponent;
+    Thead: GenericComponent;
+    Tbody: GenericComponent;
+    Tr: GenericComponent;
+    Th: GenericComponent;
+    Td: GenericComponent;
+}
+type HtmlElements = Record<string, GenericComponent>;
+type InlineHtmlRenderer = (descriptor: InlineHtmlDescriptor, context: {
+    key?: React__default.Key;
+    defaultRender: () => React__default.ReactElement | null;
+}) => React__default.ReactElement | null;
+type InlineHtmlRendererMap = Record<string, InlineHtmlRenderer>;
+type InlineComponents = Record<string, GenericComponent> & {
+    text: React__default.FC<{
+        text: string;
+    }>;
+    strong: React__default.FC<{
+        children: React__default.ReactNode;
+    }>;
+    em: React__default.FC<{
+        children: React__default.ReactNode;
+    }>;
+    strike?: React__default.FC<{
+        children: React__default.ReactNode;
+    }>;
+    code: React__default.FC<{
+        text: string;
+    }>;
+    link: React__default.FC<{
+        href?: string;
+        title?: string;
+        children: React__default.ReactNode;
+    }>;
+    image: React__default.FC<{
+        src?: string;
+        alt?: string;
+        title?: string;
+    }>;
+    br: React__default.FC<Record<string, never>>;
+};
+type NativeNodeKey = "paragraph" | "heading" | "code" | "blockquote" | "list" | "list-item" | "list-item-ordered" | "list-item-unordered" | "table" | "table-row" | "table-cell" | "html" | "mdx" | "hr" | "footnotes" | "footnote-def" | "callout";
+type NodePresentationKey = NativeNodeKey | `inline:${string}` | `html:${string}` | `component:${string}` | `extension:${string}`;
+interface NodeChildRange {
+    readonly from: number;
+    readonly to: number;
+}
+interface NodeHandleMetadata {
+    readonly id: string;
+    readonly type: string;
+    readonly generation: number;
+    readonly revision: number;
+    readonly childCount: number;
+    readonly isFinalized: boolean;
+}
+/** Opaque read-only identity and subscriptions for one node in one document generation. */
+interface NodeHandle {
+    readonly id: string;
+    readonly type: string;
+    readonly generation: number;
+    readonly readMetadata: () => NodeHandleMetadata;
+    readonly readChildren: (range: NodeChildRange) => readonly NodeHandle[];
+    readonly subscribeMetadata: (listener: () => void) => () => void;
+    readonly subscribeChildren: (range: NodeChildRange, listener: () => void) => () => void;
+}
+interface NodeViewMetadata {
+    readonly id: string;
+    readonly type: string;
+    readonly isFinalized: boolean;
+    readonly language?: string;
+    readonly lineCount?: number;
+    readonly rowCount?: number;
+    readonly columnCount?: number;
+    readonly align?: ReadonlyArray<"left" | "center" | "right" | null>;
+    readonly linkReferences?: ReadonlyArray<BlockResolvedLinkReference>;
+}
+interface NodeViewActions {
+    readonly readSource: () => string;
+    readonly copy: () => Promise<boolean>;
+    readonly download: () => void;
+}
+/** An L1 wrapper receives the already-prepared native view as its children. */
+interface NodeViewProps {
+    readonly children: React__default.ReactNode;
+    readonly metadata: NodeViewMetadata;
+    readonly actions: NodeViewActions;
+}
+interface InlineNodeViewProps {
+    readonly node: InlineNode;
+    /** Prepared native children; math nodes expose their engine-rendered view here. */
+    readonly children?: React__default.ReactNode;
+    readonly metadata: NodeViewMetadata;
+    readonly actions: NodeViewActions;
+}
+interface HtmlNodeViewProps {
+    readonly tagName: string;
+    /** Sanitized, URL-transformed native attributes. */
+    readonly properties: Readonly<Record<string, unknown>>;
+    readonly children?: React__default.ReactNode;
+    readonly metadata: NodeViewMetadata;
+    readonly actions: NodeViewActions;
+}
+type HeadlessNodeViewProps<K extends NodePresentationKey = NodePresentationKey> = K extends "code" ? {
+    readonly handle: CodeNodeHandle;
+} : K extends "table" ? {
+    readonly handle: TableNodeHandle;
+} : K extends `inline:${string}` | `extension:${string}` ? InlineNodeViewProps : K extends `html:${string}` ? HtmlNodeViewProps : {
+    readonly handle: NodeHandle;
+};
+interface PresentationProps {
+    readonly className?: string;
+    readonly style?: React__default.CSSProperties;
+    readonly title?: string;
+    readonly [name: `data-${string}`]: string | number | boolean | undefined;
+    readonly [name: `aria-${string}`]: string | number | boolean | undefined;
+}
+interface NativeActionSlot {
+    readonly actions?: React__default.ReactNode;
+}
+type NodePresentationSlots<K extends NodePresentationKey> = K extends "code" | "table" ? NativeActionSlot : never;
+type NodePresentation<K extends NodePresentationKey = NodePresentationKey> = Readonly<{
+    props?: PresentationProps;
+    slots?: NodePresentationSlots<K>;
+}> & ([
+    K
+] extends ["table-row" | "table-cell" | `component:${string}`] ? {
+    readonly wrapper?: React__default.ComponentType<NodeViewProps>;
+    readonly view?: never;
+} : {
+    readonly wrapper?: React__default.ComponentType<NodeViewProps>;
+    readonly view?: never;
+} | {
+    readonly view: React__default.ComponentType<HeadlessNodeViewProps<K>>;
+    readonly wrapper?: never;
+});
+type NodePresentations = Partial<{
+    [K in NodePresentationKey]: NodePresentation<K>;
+}>;
+type MathEngineOutput = React__default.ReactNode;
+/** Synchronous renderer for TeX content on the main thread. */
+interface MathEngine {
+    readonly id: string;
+    render(tex: string, options: {
+        displayMode: boolean;
+    }): MathEngineOutput;
+}
+/** Input supplied by the native code owner to an opt-in Mermaid presentation engine. */
+interface MermaidEngineProps {
+    readonly source: string;
+    readonly children: React__default.ReactNode;
+    readonly metadata: NodeViewMetadata;
+    readonly actions: NodeViewActions;
+}
+/** Main-thread diagram presentation for Mermaid code fences. */
+interface MermaidEngine {
+    readonly id: string;
+    readonly view: React__default.ComponentType<MermaidEngineProps>;
+}
+interface RendererConfig extends ElementFilterOptions {
+    themes?: {
+        light: string;
+        dark: string;
+    };
+    highlight?: {
+        browserEngine?: "js" | "wasm";
+        serverEngine?: "wasm";
+        langs?: string[];
+    };
+    sanitization?: {
+        schemaId?: string;
+    };
+    contentPolicy?: ContentPolicy;
+    contentComponents?: ContentComponentsMap;
+    components?: NodePresentations;
+    engines?: {
+        code?: CodeEngine;
+        math?: MathEngine;
+        mermaid?: MermaidEngine;
+        mdx?: TrustedMdxEngine;
+    };
+    plugins?: {
+        footnotes?: boolean;
+        html?: boolean;
+        mdx?: boolean;
+        tables?: boolean;
+        callouts?: boolean;
+        math?: boolean;
+        formatAnticipation?: FormatAnticipationConfig;
+        codeHighlighting?: CodeHighlightingMode;
+        outputMode?: CodeHighlightOutputMode;
+        liveCodeHighlighting?: boolean;
+        liveTokenization?: boolean;
+        emitHighlightTokens?: boolean;
+        emitDiffBlocks?: boolean;
+    };
+    syntax?: SyntaxExtensionDescriptor;
+    html?: HtmlOptions;
+    urlTransform?: (url: string, attribute: "href" | "src", context: {
+        source: "markdown" | "html";
+    }) => string | null | undefined;
+    tableVirtualization?: TableVirtualizationOptions;
+    codeVirtualization?: Partial<VirtualizedCodeConfig>;
+    performance?: {
+        frameBudgetMs?: number;
+        flushTimeoutMs?: number;
+        maxBatchesPerFlush?: number;
+        maxLowPriorityBatchesPerFlush?: number;
+        lowPriorityFrameBudgetMs?: number;
+        urgentQueueThreshold?: number;
+        batch?: "rAF" | "microtask" | "timeout";
+        historyLimit?: number;
+        startupMicrotaskFlushes?: number;
+        adaptiveBudgeting?: boolean;
+    };
+    controls?: ControlsConfig;
+    controlsComponent?: React__default.ComponentType<ControlsComponentProps>;
+}
+interface RendererStore {
+    reset(blocks: Block[]): void;
+    getBlocks(): ReadonlyArray<Block>;
+    getVersion(): number;
+    subscribe(listener: () => void): () => void;
+}
+type CodeHighlightRangeRequest = {
+    blockId: string;
+    startLine: number;
+    endLine: number;
+    priority?: LazyTokenizationPriority;
+};
+interface Renderer {
+    attachWorker(worker: Worker, options?: {
+        skipInit?: boolean;
+    }): void;
+    /** Resolve after the attached worker supplies its matching initial root, before queued source dispatch. */
+    whenInitialized(): Promise<void>;
+    finalize(): Promise<FinalizeResult>;
+    renderStatic(text: string): Promise<Block[]>;
+    onUpdate(cb: (blocks: ReadonlyArray<Block>) => void): () => void;
+    setTableVirtualization(options: TableVirtualizationOptions): void;
+    getComponentRegistry(): ComponentRegistry;
+    getStore(): RendererStore;
+    requestCodeHighlightRange(request: CodeHighlightRangeRequest): void;
+    setControls(controls: ControlsConfig): void;
+    setControlsComponent(component?: React__default.ComponentType<ControlsComponentProps>): void;
+}
+type AnimatedAnimationName = "fadeIn" | "blurIn" | "slideUp" | (string & {});
+interface AnimatedOptions {
+    animation?: AnimatedAnimationName;
+    duration?: number;
+    easing?: string;
+    sep?: "word" | "char";
+    stagger?: number;
+    maxBacklogMs?: number;
+}
+type AnimatedProp = boolean | AnimatedOptions;
+
+interface KaTeXModule {
+    renderToString(tex: string, options?: {
+        displayMode?: boolean;
+        throwOnError?: boolean;
+        trust?: boolean;
+        maxExpand?: number;
+        macros?: Record<string, unknown>;
+        [key: string]: unknown;
+    }): string;
+}
+declare function loadKaTeX(): Promise<KaTeXModule>;
+type MathPreparation = {
+    tex: string;
+    displayMode: boolean;
+    scope: DocumentMathMacroScope | null;
+    html: string;
+} | {
+    tex: string;
+    displayMode: boolean;
+    scope: DocumentMathMacroScope | null;
+    error: Error;
+};
+declare class DocumentMathMacroScope {
+    private readonly entries;
+    private orderedEntries;
+    private macroSnapshots;
+    private katex;
+    private loadError;
+    private loading;
+    private disposed;
+    register(element: HTMLElement, tex: string, displayMode: boolean, complete: boolean, publish: (preparation: MathPreparation | null) => void): () => void;
+    dispose(): void;
+    private refresh;
+    private recompute;
+}
+declare const DocumentMathMacroScopeContext: React__default.Context<DocumentMathMacroScope | null>;
+declare const MathExpressionCompletenessContext: React__default.Context<boolean>;
+interface KaTeXMathProps {
+    tex: string;
+    className?: string;
+    errorColor?: string;
+    fallback?: (tex: string, error?: Error) => React__default.ReactNode;
+    engine?: MathEngine;
+}
+declare const KaTeXInlineMath: React__default.FC<KaTeXMathProps>;
+declare const KaTeXBlockMath: React__default.FC<KaTeXMathProps>;
+
+declare const DEFAULT_CONTROLS_LABELS: ControlsLabels;
+declare const LANGUAGE_EXTENSION_MAP: Record<string, string>;
+declare function getExtensionForLanguage(lang?: string): string;
+declare function getCodeSnippetFilename(lang?: string): string;
+declare function copyToClipboard(text: string): Promise<boolean>;
+declare function downloadFile(content: string, filename: string, mimeType?: string): void;
+declare function escapeCsvCell(cell: string): string;
+declare function escapeTsvCell(cell: string): string;
+declare function tableToCsv(headers: string[], rows: string[][]): string;
+declare function tableToTsv(headers: string[], rows: string[][]): string;
+declare function tableToMarkdown(headers: string[], rows: string[][], align?: Array<"left" | "center" | "right" | null>): string;
+declare function inlineToPlainText(nodes?: InlineNode[]): string;
+interface ResolvedCodeControls {
+    enabled: boolean;
+    copy: boolean;
+    download: boolean;
+    labels: ControlsLabels;
+}
+declare function resolveCodeControls(config?: ControlsConfig): ResolvedCodeControls;
+interface ResolvedTableControls {
+    enabled: boolean;
+    copy: boolean;
+    copyFormats: TableCopyFormat[];
+    download: boolean;
+    downloadFormats: TableDownloadFormat[];
+    labels: ControlsLabels;
+}
+declare function resolveTableControls(config?: ControlsConfig): ResolvedTableControls;
+interface ResolvedMermaidControls {
+    enabled: boolean;
+    copy: boolean;
+    fullscreen: boolean;
+    labels: ControlsLabels;
+}
+declare function resolveMermaidControls(config?: ControlsConfig): ResolvedMermaidControls;
+declare function resolveControlsConfig(config?: ControlsConfig): {
+    code: ResolvedCodeControls;
+    table: ResolvedTableControls;
+    mermaid: ResolvedMermaidControls;
+};
+interface CodeControlsBarProps {
+    code: string;
+    language?: string;
+    config: ResolvedCodeControls;
+    className?: string;
+}
+declare const CodeControlsBar: React__default.FC<CodeControlsBarProps>;
+interface TableControlsData {
+    headers: string[];
+    rows: string[][];
+    align?: Array<"left" | "center" | "right" | null>;
+}
+interface TableControlsBarProps {
+    headers: string[];
+    rows: string[][];
+    align?: Array<"left" | "center" | "right" | null>;
+    getTableData?: () => TableControlsData;
+    getMarkdownSource?: () => string;
+    isFinalized: boolean;
+    config: ResolvedTableControls;
+    className?: string;
+}
+declare const TableControlsBar: React__default.FC<TableControlsBarProps>;
+interface CodeBlockCopyButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    code: string;
+    labels?: ControlsLabels;
+}
+declare const CodeBlockCopyButton: React__default.FC<CodeBlockCopyButtonProps>;
+interface CodeBlockDownloadButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    code: string;
+    language?: string;
+    filename?: string;
+    labels?: ControlsLabels;
+}
+declare const CodeBlockDownloadButton: React__default.FC<CodeBlockDownloadButtonProps>;
+
+interface ResolvedAnimatedOptions {
+    animation: AnimatedAnimationName;
+    animationName: string;
+    duration: number;
+    durationStr: string;
+    easing: string;
+    sep: "word" | "char";
+    stagger: number;
+    maxBacklogMs: number;
+}
+declare const DEFAULT_ANIMATED_OPTIONS: ResolvedAnimatedOptions;
+declare function resolveAnimatedOptions(prop: AnimatedProp | undefined): ResolvedAnimatedOptions | null;
+declare const STREAM_MDX_ANIMATION_CSS: string;
+declare function splitWordSegments(text: string): string[];
+declare function splitTextSegments(text: string, sep: "word" | "char"): string[];
+declare class AnimationTimeline {
+    private now;
+    private maxBacklogMs;
+    private stagger;
+    private committedEndTime;
+    private cursorEndTime;
+    private passActive;
+    private nodeStates;
+    constructor(options?: {
+        now?: () => number;
+        maxBacklogMs?: number;
+        stagger?: number;
+    });
+    updateOptions(options: {
+        maxBacklogMs?: number;
+        stagger?: number;
+    }): void;
+    beginPass(currentTime?: number): void;
+    commitPass(): void;
+    schedule(count: number, stagger?: number, currentTime?: number): number[];
+    getNodeState(key: string): {
+        count: number;
+        delays: number[];
+    };
+    reset(): void;
+    releasePrefix(prefix: string): void;
+}
+interface RenderInlineAnimationContext {
+    isFinalized?: boolean;
+    animated?: ResolvedAnimatedOptions | null;
+    timeline?: AnimationTimeline | null;
+    nodeKeyPrefix?: string;
+}
+
+type LinkSafetyModalProps = {
+    url: string;
+    isOpen: boolean;
+    isChecking?: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    onCopy: () => void;
+};
+declare const DefaultLinkSafetyModal: React__default.FC<LinkSafetyModalProps>;
+
+type InlinePresentationContext = RenderInlineAnimationContext & {
+    readonly sourceGuard?: () => void;
+};
+/**
+ * Render inline nodes to React elements
+ */
+declare function renderInlineNodes(nodes: ReadonlyArray<InlineNode>, components: InlineComponents, urlTransform?: UrlTransform, registry?: ComponentRegistry, parentTagName?: string, animationContext?: InlinePresentationContext): React__default.ReactNode;
+/**
+ * Default inline components
+ */
+declare const defaultInlineComponents: InlineComponents;
+/**
+ * Component registry that allows customization
+ */
+declare class ComponentRegistry {
+    private nodePresentations;
+    private inlineComponents;
+    private htmlElements;
+    private defaultHtmlInlineRenderer;
+    private tableElements;
+    private literalTagContent?;
+    private contentComponents?;
+    private mathEngine?;
+    private mermaidEngine?;
+    private tableVirtualization;
+    private tableVirtualizationListeners;
+    private codeVirtualization;
+    private codeVirtualizationListeners;
+    private inlineComponentMapCache;
+    private urlTransform?;
+    private controls;
+    private controlsComponent?;
+    private animated?;
+    private animatedOptions;
+    private animationTimeline;
+    private allowedElements?;
+    private disallowedElements?;
+    private allowElement?;
+    private unwrapDisallowed?;
+    private disableAutolinkProtocols?;
+    private hasFilterConfig;
+    constructor(options?: {
+        tableVirtualization?: TableVirtualizationOptions;
+        codeVirtualization?: Partial<VirtualizedCodeConfig>;
+        urlTransform?: UrlTransform;
+        controls?: ControlsConfig;
+        controlsComponent?: React__default.ComponentType<ControlsComponentProps>;
+        animated?: AnimatedProp;
+        contentComponents?: ContentComponentsMap;
+        components?: NodePresentations;
+        engines?: {
+            math?: MathEngine;
+            mermaid?: MermaidEngine;
+        };
+    } & ElementFilterOptions);
+    setLinkSafetyRenderer(renderer?: InlineComponents["link"]): void;
+    hasElementFilters(): boolean;
+    /** Replaces the whole filter configuration at once so prop swaps (allowed -> disallowed) never trip the exclusivity check. */
+    setElementFilters(options: ElementFilterOptions): void;
+    isAutolinkProtocolDisabled(href?: string): boolean;
+    isElementAllowed(element: ElementFilterDescriptor, context: ElementFilterContext): boolean;
+    filterElement(element: ElementFilterDescriptor, context: ElementFilterContext, renderElement: () => React__default.ReactNode, renderChildren?: () => React__default.ReactNode): React__default.ReactNode;
+    setUrlTransform(transform?: UrlTransform): void;
+    setAnimated(animated?: AnimatedProp): void;
+    getAnimated(): AnimatedProp | undefined;
+    getAnimatedOptions(): ResolvedAnimatedOptions | null;
+    getAnimationTimeline(): AnimationTimeline | null;
+    getRenderInlineContext(isFinalized?: boolean, blockId?: string, sourceGuard?: () => void): InlinePresentationContext | undefined;
+    resetAnimationTimeline(): void;
+    getUrlTransform(): UrlTransform | undefined;
+    releaseFinalizedBlockAnimations(blockId: string): void;
+    setNodePresentations(presentations?: NodePresentations): void;
+    getNodePresentation<K extends keyof NodePresentations & string>(key: K): NodePresentations[K] | undefined;
+    isDefaultHtmlInlineRenderer(renderer: InlineComponents["html"] | undefined): boolean;
+    renderInlinePresentation(node: InlineNode, nativeView: React__default.ReactNode, key: React__default.Key, context?: InlinePresentationContext, renderedChildren?: React__default.ReactNode): React__default.ReactNode;
+    renderHtmlPresentation(tagName: string, properties: Readonly<Record<string, unknown>>, nativeView: React__default.ReactNode, children: React__default.ReactNode, key: React__default.Key, ownerId?: string, isFinalized?: boolean, sourceGuard?: () => void): React__default.ReactNode;
+    renderComponentPresentation(name: string, nativeView: React__default.ReactElement, children: React__default.ReactNode, key: React__default.Key, status: "open" | "closed" | "incomplete", rawSource?: string, ownerId?: string, sourceGuard?: () => void): React__default.ReactNode;
+    /** Get HTML element mapping */
+    getHtmlElements(): HtmlElements;
+    /** Update literal tag content list */
+    setLiteralTagContent(tags?: string[]): void;
+    /** Get literal tag content list */
+    getLiteralTagContent(): string[] | undefined;
+    setControls(controls?: ControlsConfig): void;
+    getControls(): ControlsConfig;
+    setControlsComponent(component?: React__default.ComponentType<ControlsComponentProps>): void;
+    getControlsComponent(): React__default.ComponentType<ControlsComponentProps> | undefined;
+    /**
+     * Get block component
+     */
+    getBlockComponent(type: string): GenericComponent;
+    getCodeNodeView(): React__default.ComponentType<HeadlessNodeViewProps<"code">> | undefined;
+    /**
+     * Get inline components
+     */
+    getInlineComponents(): InlineComponents;
+    getMathEngine(): MathEngine | undefined;
+    setMermaidEngine(engine?: MermaidEngine): void;
+    getMermaidEngine(): MermaidEngine | undefined;
+    setContentComponents(contentComponents?: ContentComponentsMap): void;
+    getContentComponents(): ContentComponentsMap | undefined;
+    renderHtmlTree(tree: HtmlTreeNode[], renderBlock?: (block: Block, parentTagName?: string) => React__default.ReactNode, paragraph?: Block, parentTagName?: string, renderParagraphPresentation?: (nativeView: React__default.ReactNode) => React__default.ReactNode, sourceGuard?: () => void): React__default.ReactNode;
+    private ownedHtmlRenderContext;
+    getTableElements(): TableElements;
+    subscribeTableVirtualization(listener: () => void): () => void;
+    setTableVirtualization(options: TableVirtualizationOptions | undefined): void;
+    getTableVirtualization(): TableVirtualizationConfig;
+    subscribeCodeVirtualization(listener: () => void): () => void;
+    setCodeVirtualization(options: Partial<VirtualizedCodeConfig> | undefined): void;
+    getCodeVirtualization(): VirtualizedCodeConfig;
+    /**
+     * Render a block
+     */
+    renderBlock(block: Block, renderPresentation?: (nativeView: React__default.ReactNode) => React__default.ReactNode, sourceGuard?: () => void): React__default.ReactElement;
+    /**
+     * Get props for a block based on its type
+     */
+    private getBlockProps;
+    /**
+     * Extract heading level from raw markdown
+     */
+    private extractHeadingLevel;
+}
+declare function mapHtmlToReact(html: string, elements: HtmlElements, literalTagContent?: string[], parseMarkdown?: (text: string) => React__default.ReactNode): React__default.ReactNode;
+declare function renderParagraphMixedSegments(segments: MixedContentSegment[], inlineComponents: InlineComponents, inlineHtmlRenderers: InlineHtmlRendererMap, htmlElements?: HtmlElements, literalTagContent?: string[], urlTransform?: UrlTransform): React__default.ReactNode[];
+
+export { type MermaidEngine as $, type AllowElementFn as A, type BroadContentComponentOptions as B, type ContentComponentsMap as C, DEFAULT_ANIMATED_OPTIONS as D, type ElementFilterContext as E, CodeBlockDownloadButton as F, escapeCsvCell as G, type HtmlElements as H, type InlineHtmlRendererMap as I, escapeTsvCell as J, tableToCsv as K, tableToTsv as L, type MathOptions as M, tableToMarkdown as N, inlineToPlainText as O, getCodeSnippetFilename as P, getExtensionForLanguage as Q, type Renderer as R, STREAM_MDX_ANIMATION_CSS as S, type TableVirtualizationOptions as T, resolveControlsConfig as U, type ValidatedContentComponentOptions as V, resolveCodeControls as W, resolveTableControls as X, resolveMermaidControls as Y, DEFAULT_CONTROLS_LABELS as Z, type NodePresentations as _, type RendererConfig as a, type NodeHandle as a0, type LinkSafetyModalProps as a1, type MathEngine as a2, type NodeHandleMetadata as a3, type NodeChildRange as a4, DEFAULT_TABLE_VIRTUALIZATION_CONFIG as a5, type MathEngineOutput as a6, type MermaidEngineProps as a7, type HeadlessNodeViewProps as a8, type HtmlNodeViewProps as a9, LANGUAGE_EXTENSION_MAP as aA, copyToClipboard as aB, downloadFile as aC, type ResolvedCodeControls as aD, type ResolvedTableControls as aE, type ResolvedMermaidControls as aF, type CodeControlsBarProps as aG, type TableControlsData as aH, type TableControlsBarProps as aI, type CodeBlockCopyButtonProps as aJ, type CodeBlockDownloadButtonProps as aK, type InlineNodeViewProps as aa, type NativeNodeKey as ab, type NodePresentation as ac, type NodePresentationKey as ad, type NativeActionSlot as ae, type NodeViewActions as af, type NodeViewMetadata as ag, type NodeViewProps as ah, type PresentationProps as ai, renderInlineNodes as aj, defaultInlineComponents as ak, mapHtmlToReact as al, renderParagraphMixedSegments as am, AnimationTimeline as an, splitTextSegments as ao, splitWordSegments as ap, resolveAnimatedOptions as aq, type RenderInlineAnimationContext as ar, DefaultLinkSafetyModal as as, loadKaTeX as at, DocumentMathMacroScope as au, DocumentMathMacroScopeContext as av, MathExpressionCompletenessContext as aw, type KaTeXMathProps as ax, KaTeXInlineMath as ay, KaTeXBlockMath as az, type ControlsConfig as b, type ControlsComponentProps as c, ComponentRegistry as d, type CodeHighlightRangeRequest as e, defineContentComponent as f, type ContentComponentHostProps as g, type ContentComponentProps as h, type ContentComponentPropsGuard as i, type ContentComponentRegistration as j, type ElementFilterDescriptor as k, type ElementFilterOptions as l, type InlineHtmlRenderer as m, type ControlsOptions as n, type CodeControlsConfig as o, type TableControlsConfig as p, type MermaidControlsConfig as q, type ControlsLabels as r, type TableDownloadFormat as s, type TableCopyFormat as t, type AnimatedAnimationName as u, type AnimatedOptions as v, type AnimatedProp as w, CodeControlsBar as x, TableControlsBar as y, CodeBlockCopyButton as z };