markstream-vue 0.0.10 → 0.0.11

package/dist/index.d.ts

@@ -1,60 +1,1607 @@
-import { Plugin } from 'vue';
-import { CustomComponents as MarkstreamCustomComponents } from './types/types';
-import { default as AdmonitionNode } from './types/components/AdmonitionNode';
-import { default as BlockquoteNode } from './types/components/BlockquoteNode';
-import { default as CheckboxNode } from './types/components/CheckboxNode';
-import { disableD2, enableD2, isD2Enabled, setD2Loader } from './types/components/D2BlockNode/d2';
-import { default as DefinitionListNode } from './types/components/DefinitionListNode';
-import { default as EmojiNode } from './types/components/EmojiNode';
-import { default as EmphasisNode } from './types/components/EmphasisNode';
-import { default as FootnoteAnchorNode } from './types/components/FootnoteAnchorNode';
-import { default as FootnoteNode } from './types/components/FootnoteNode';
-import { default as FootnoteReferenceNode } from './types/components/FootnoteReferenceNode';
-import { default as HardBreakNode } from './types/components/HardBreakNode';
-import { default as HeadingNode } from './types/components/HeadingNode';
-import { default as HighlightNode } from './types/components/HighlightNode';
-import { default as HtmlBlockNode } from './types/components/HtmlBlockNode';
-import { default as HtmlInlineNode } from './types/components/HtmlInlineNode';
-import { default as ImageNode } from './types/components/ImageNode';
-import { default as InlineCodeNode } from './types/components/InlineCodeNode';
-import { default as InsertNode } from './types/components/InsertNode';
-import { default as LinkNode } from './types/components/LinkNode';
-import { default as ListItemNode } from './types/components/ListItemNode';
-import { default as ListNode } from './types/components/ListNode';
-import { default as MarkdownCodeBlockNode } from './types/components/MarkdownCodeBlockNode';
-import { disableKatex, enableKatex, isKatexEnabled, setKatexLoader } from './types/components/MathInlineNode/katex';
-import { disableMermaid, enableMermaid, isMermaidEnabled, setMermaidLoader } from './types/components/MermaidBlockNode/mermaid';
-import { default as MarkdownRender } from './types/components/NodeRenderer';
-import { default as ParagraphNode } from './types/components/ParagraphNode';
-import { default as PreCodeNode } from './types/components/PreCodeNode';
-import { default as ReferenceNode } from './types/components/ReferenceNode';
-import { default as StrikethroughNode } from './types/components/StrikethroughNode';
-import { default as StrongNode } from './types/components/StrongNode';
-import { default as SubscriptNode } from './types/components/SubscriptNode';
-import { default as SuperscriptNode } from './types/components/SuperscriptNode';
-import { default as TableNode } from './types/components/TableNode';
-import { default as TextNode } from './types/components/TextNode';
-import { default as ThematicBreakNode } from './types/components/ThematicBreakNode';
-import { default as Tooltip } from './types/components/Tooltip';
-import { default as VmrContainerNode } from './types/components/VmrContainerNode';
-import { setDefaultI18nMap } from './types/composables/useSafeI18n';
-import { clearGlobalCustomComponents, getCustomNodeComponents, removeCustomComponents, setCustomComponents } from './types/utils/nodeComponents';
+import * as vue from 'vue';
+import { Component, Plugin } from 'vue';
+import { CodeBlockNode as CodeBlockNode$1, BaseNode, ParseOptions, MarkdownIt } from 'stream-markdown-parser';
+export * from 'stream-markdown-parser';
+export { KATEX_COMMANDS, MathOptions, normalizeStandaloneBackslashT, setDefaultMathOptions } from 'stream-markdown-parser';
+
+/**
+ * Monaco theme name or a lightweight theme object accepted by `stream-monaco`.
+ *
+ * Keep this intentionally local so `markstream-vue` does not force consumers to
+ * install `stream-monaco` just to resolve exported types.
+ */
+interface CodeBlockMonacoThemeObject {
+    name: string;
+    base?: string;
+    inherit?: boolean;
+    colors?: Record<string, string>;
+    rules?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+/**
+ * Theme entries forwarded to Monaco-backed code blocks.
+ */
+type CodeBlockMonacoTheme = string | CodeBlockMonacoThemeObject;
+/**
+ * Unified theme prop for code blocks.
+ *
+ * - `string` or `CodeBlockMonacoThemeObject`: fixed theme, ignores page dark/light
+ * - `{ light, dark }`: auto-switches based on page isDark
+ */
+type CodeBlockThemeProp = CodeBlockMonacoTheme | {
+    light: CodeBlockMonacoTheme;
+    dark: CodeBlockMonacoTheme;
+};
+/**
+ * Common language entry accepted by `stream-monaco`.
+ *
+ * The runtime also supports advanced lazy-loader signatures; keep the union
+ * broad here so hover remains useful without depending on `stream-monaco`.
+ */
+type CodeBlockMonacoLanguage = string | ((...args: any[]) => unknown);
+/**
+ * Object form of Monaco's unchanged-region folding settings.
+ */
+interface CodeBlockDiffHideUnchangedRegionsOptions {
+    /** Enable unchanged-region folding for diff editors. */
+    enabled?: boolean;
+    /** Number of context lines to keep visible around each change. */
+    contextLineCount?: number;
+    /** Minimum unchanged span required before a region can collapse. */
+    minimumLineCount?: number;
+    /** Number of lines to reveal when the user expands a collapsed region. */
+    revealLineCount?: number;
+}
+type CodeBlockDiffHideUnchangedRegions = boolean | CodeBlockDiffHideUnchangedRegionsOptions;
+/**
+ * Visual treatment for changed diff lines.
+ */
+type CodeBlockDiffLineStyle = 'background' | 'bar';
+/**
+ * Shell appearance for the Monaco diff surface.
+ */
+type CodeBlockDiffAppearance = 'auto' | 'light' | 'dark';
+/**
+ * Rendering style for collapsed unchanged diff regions.
+ */
+type CodeBlockDiffUnchangedRegionStyle = 'line-info' | 'line-info-basic' | 'metadata' | 'simple';
+/**
+ * Action names emitted by Monaco diff hunk hover controls.
+ */
+type CodeBlockDiffHunkActionKind = 'revert' | 'stage';
+/**
+ * Which half of the diff hunk triggered the action.
+ */
+type CodeBlockDiffHunkSide = 'upper' | 'lower';
+/**
+ * Minimal action context forwarded from `stream-monaco`.
+ *
+ * Use `action` and `side` for the stable contract. The model payloads are kept
+ * intentionally loose to avoid introducing `stream-monaco` or Monaco types into
+ * `markstream-vue`'s public declarations.
+ */
+interface CodeBlockDiffHunkActionContext {
+    /** The requested hunk action. */
+    action: CodeBlockDiffHunkActionKind;
+    /** Which hunk half triggered the action. */
+    side: CodeBlockDiffHunkSide;
+    /** Raw Monaco diff metadata for the current hunk. */
+    lineChange: unknown;
+    /** Original Monaco model for the diff editor. */
+    originalModel: unknown;
+    /** Modified Monaco model for the diff editor. */
+    modifiedModel: unknown;
+}
+/**
+ * Monaco editor options forwarded by `CodeBlockNode`.
+ *
+ * This mirrors the most common `stream-monaco` options used in markstream-vue's
+ * docs and examples while leaving the index signature available for advanced
+ * options not modeled here yet.
+ */
+interface CodeBlockMonacoOptions {
+    /** Maximum editor height before the code block starts scrolling internally. */
+    MAX_HEIGHT?: number | string;
+    /** Base font size for Monaco-rendered code. */
+    fontSize?: number;
+    /** Explicit line height for the Monaco editor. */
+    lineHeight?: number;
+    /** Font family override applied to the Monaco editor surface. */
+    fontFamily?: string;
+    /** Tab width forwarded to Monaco. */
+    tabSize?: number;
+    /** Render the Monaco editor in read-only mode. */
+    readOnly?: boolean;
+    /** Monaco word-wrap mode for long lines. */
+    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded' | string;
+    /** Indentation strategy used when wrapping long lines. */
+    wrappingIndent?: 'none' | 'same' | 'indent' | 'deepIndent' | string;
+    /** Monaco theme name to apply on initial render. */
+    theme?: string;
+    /** Theme names or theme objects available for this code block. */
+    themes?: CodeBlockMonacoTheme[];
+    /**
+     * Language ids or lazy loaders to register with `stream-monaco`.
+     *
+     * Supplying this array replaces the default built-in language list.
+     */
+    languages?: CodeBlockMonacoLanguage[];
+    /** Render diff editors side-by-side instead of inline. */
+    renderSideBySide?: boolean;
+    /** Allow resizing the split handle in side-by-side diff mode. */
+    enableSplitViewResizing?: boolean;
+    /** Keep whitespace-only changes visible in Monaco diff editors. */
+    ignoreTrimWhitespace?: boolean;
+    /** Disable Monaco's diff computation timeout for large diffs when needed. */
+    maxComputationTime?: number;
+    /** Choose Monaco's diff algorithm. */
+    diffAlgorithm?: string;
+    /** Show change indicators in the gutter. */
+    renderIndicators?: boolean;
+    /** Allow editing the original side of a diff editor. */
+    originalEditable?: boolean;
+    /** Debounce repeated reveal requests while content is streaming. */
+    revealDebounceMs?: number;
+    /** How Monaco should reveal the active line while auto-scrolling. */
+    revealStrategy?: 'bottom' | 'centerIfOutside' | 'center';
+    /** Delay a final reveal until streaming settles for this many milliseconds. */
+    revealBatchOnIdleMs?: number;
+    /** Extra throttle window for normal `updateCode` calls. */
+    updateThrottleMs?: number;
+    /** Extra throttle window for diff streaming updates. */
+    diffUpdateThrottleMs?: number;
+    /** Enable automatic scrolling on the modified side of diff editors. */
+    diffAutoScroll?: boolean;
+    /** Fold unchanged diff regions with Monaco's diff viewer. */
+    diffHideUnchangedRegions?: CodeBlockDiffHideUnchangedRegions;
+    /** Visual emphasis used for changed diff lines. */
+    diffLineStyle?: CodeBlockDiffLineStyle;
+    /** Light/dark chrome mode for Monaco's diff shell. */
+    diffAppearance?: CodeBlockDiffAppearance;
+    /** Visual style used for collapsed unchanged diff regions. */
+    diffUnchangedRegionStyle?: CodeBlockDiffUnchangedRegionStyle;
+    /** Show per-hunk hover actions such as `revert` and `stage`. */
+    diffHunkActionsOnHover?: boolean;
+    /** Delay before diff hover action widgets hide after mouse leave. */
+    diffHunkHoverHideDelayMs?: number;
+    /**
+     * Intercept diff hunk hover actions before `stream-monaco` applies its
+     * default local model edits. Return `false` to skip the built-in behavior.
+     */
+    onDiffHunkAction?: (context: CodeBlockDiffHunkActionContext) => void | boolean | Promise<void | boolean>;
+    scrollbar?: Record<string, any>;
+    [key: string]: any;
+}
+interface CodeBlockNodeProps {
+    node: CodeBlockNode$1;
+    isDark?: boolean;
+    loading?: boolean;
+    stream?: boolean;
+    /**
+     * Unified theme configuration.
+     * - `string` or theme object: fixed theme, ignores page dark/light switch
+     * - `{ light, dark }`: auto-switches based on `isDark`
+     * - When omitted, falls back to `darkTheme`/`lightTheme` props
+     */
+    theme?: CodeBlockThemeProp;
+    /** @deprecated Use `theme` prop instead. Kept for backward compatibility. */
+    darkTheme?: CodeBlockMonacoTheme;
+    /** @deprecated Use `theme` prop instead. Kept for backward compatibility. */
+    lightTheme?: CodeBlockMonacoTheme;
+    isShowPreview?: boolean;
+    /** Monaco editor and diff behavior forwarded to `stream-monaco`. */
+    monacoOptions?: CodeBlockMonacoOptions;
+    enableFontSizeControl?: boolean;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    /** Theme names or theme objects preloaded for this code block instance. */
+    themes?: CodeBlockMonacoTheme[];
+    showHeader?: boolean;
+    showCopyButton?: boolean;
+    showExpandButton?: boolean;
+    showPreviewButton?: boolean;
+    showCollapseButton?: boolean;
+    showFontSizeButtons?: boolean;
+    showTooltips?: boolean;
+    /** Scope key used by `setCustomComponents()` and `data-custom-id` style overrides. */
+    customId?: string;
+}
+interface ImageNodeProps {
+    node: {
+        type: 'image';
+        src: string;
+        alt: string;
+        title: string | null;
+        raw: string;
+        loading?: boolean;
+    };
+    fallbackSrc?: string;
+    lazy?: boolean;
+    usePlaceholder?: boolean;
+}
+interface LinkNodeProps {
+    node: {
+        type: 'link';
+        href: string;
+        title: string | null;
+        text: string;
+        attrs?: [string, string][];
+        children: {
+            type: string;
+            raw: string;
+        }[];
+        raw: string;
+        loading?: boolean;
+    };
+    indexKey: number | string;
+    customId?: string;
+    showTooltip?: boolean;
+    color?: string;
+    underlineHeight?: number;
+    underlineBottom?: number | string;
+    animationDuration?: number;
+    animationOpacity?: number;
+    animationTiming?: string;
+    animationIteration?: string | number;
+}
+interface PreCodeNodeProps {
+    node: CodeBlockNode$1;
+}
+interface MermaidBlockNodeProps {
+    node: CodeBlockNode$1;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    workerTimeoutMs?: number;
+    parseTimeoutMs?: number;
+    renderTimeoutMs?: number;
+    fullRenderTimeoutMs?: number;
+    renderDebounceMs?: number;
+    contentStableDelayMs?: number;
+    previewPollDelayMs?: number;
+    previewPollMaxDelayMs?: number;
+    previewPollMaxAttempts?: number;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showCollapseButton?: boolean;
+    showZoomControls?: boolean;
+    enableWheelZoom?: boolean;
+    isStrict?: boolean;
+    showTooltips?: boolean;
+    onRenderError?: (error: unknown, code: string, container: HTMLElement) => boolean | void;
+}
+interface MermaidBlockEvent<TPayload = any> {
+    payload?: TPayload;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+    svgElement?: SVGElement | null;
+    svgString?: string | null;
+}
+interface D2BlockNodeProps {
+    node: CodeBlockNode$1;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    progressiveRender?: boolean;
+    progressiveIntervalMs?: number;
+    themeId?: number | null;
+    darkThemeId?: number | null;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showCollapseButton?: boolean;
+}
+interface InfographicBlockNodeProps {
+    node: CodeBlockNode$1;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showCollapseButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showZoomControls?: boolean;
+}
+interface MathBlockNodeProps {
+    node: {
+        type: 'math_block';
+        content: string;
+        raw: string;
+        loading?: boolean;
+    };
+}
+interface MathInlineNodeProps {
+    node: {
+        type: 'math_inline';
+        content: string;
+        raw: string;
+        loading?: boolean;
+        markup?: string;
+    };
+}
+
+interface CustomComponents$1 {
+    text?: Component;
+    paragraph?: Component;
+    heading?: Component;
+    code_block?: Component;
+    list?: Component;
+    list_item?: Component;
+    blockquote?: Component;
+    table?: Component;
+    definition_list?: Component;
+    footnote?: Component;
+    footnote_reference?: Component;
+    footnote_anchor?: Component;
+    admonition?: Component;
+    hardbreak?: Component;
+    link?: Component;
+    image?: Component;
+    thematic_break?: Component;
+    math_inline?: Component;
+    math_block?: Component;
+    strong?: Component;
+    emphasis?: Component;
+    strikethrough?: Component;
+    highlight?: Component;
+    insert?: Component;
+    subscript?: Component;
+    superscript?: Component;
+    emoji?: Component;
+    checkbox?: Component;
+    inline_code?: Component;
+    html_inline?: Component;
+    html_block?: Component;
+    reference?: Component;
+    mermaid?: Component;
+    infographic?: Component;
+    d2?: Component;
+    vmr_container?: Component;
+    [key: string]: Component | undefined;
+}
+
+type AdmonitionKind = 'note' | 'info' | 'tip' | 'warning' | 'danger' | 'caution' | 'error';
+interface AdmonitionNode {
+    type: 'admonition';
+    kind: AdmonitionKind;
+    title?: string;
+    children: {
+        type: string;
+        raw: string;
+    }[];
+    raw: string;
+    collapsible?: boolean;
+    open?: boolean;
+}
+type __VLS_Props$r = {
+    node: AdmonitionNode;
+    indexKey: number | string;
+    isDark?: boolean;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$w: vue.DefineComponent<__VLS_Props$r, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$r> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+interface NodeChild$a {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+interface BlockquoteNode {
+    type: 'blockquote';
+    children: NodeChild$a[];
+    raw: string;
+    cite?: string;
+}
+type __VLS_Props$q = {
+    node: BlockquoteNode;
+    indexKey: string | number;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$v: vue.DefineComponent<__VLS_Props$q, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (text: string) => any;
+}, string, vue.PublicProps, Readonly<__VLS_Props$q> & Readonly<{
+    onCopy?: (text: string) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLQuoteElement>;
+
+type __VLS_Props$p = {
+    node: {
+        type: 'checkbox';
+        checked: boolean;
+        raw: string;
+    };
+};
+declare const _default$u: vue.DefineComponent<__VLS_Props$p, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$p> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;
+
+type D2Loader = () => Promise<any> | any;
+declare function setD2Loader(loader: D2Loader | null): void;
+declare function enableD2(loader?: D2Loader): void;
+declare function disableD2(): void;
+declare function isD2Enabled(): boolean;
+
+interface DefinitionItemNode {
+    type: 'definition_item';
+    term: {
+        type: string;
+        raw: string;
+    }[];
+    definition: {
+        type: string;
+        raw: string;
+    }[];
+    raw: string;
+}
+interface DefinitionListNode {
+    type: 'definition_list';
+    items: DefinitionItemNode[];
+    raw: string;
+}
+type __VLS_Props$o = {
+    node: DefinitionListNode;
+    indexKey: string | number;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$t: vue.DefineComponent<__VLS_Props$o, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$o> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDListElement>;
+
+type __VLS_Props$n = {
+    node: {
+        type: 'emoji';
+        name: string;
+        markup: string;
+        raw: string;
+    };
+};
+declare const _default$s: vue.DefineComponent<__VLS_Props$n, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$n> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;
+
+interface NodeChild$9 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$m = {
+    node: {
+        type: 'emphasis';
+        children: NodeChild$9[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$r: vue.DefineComponent<__VLS_Props$m, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$m> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;
+
+type __VLS_Props$l = {
+    node: {
+        type: 'footnote_anchor';
+        id: string;
+        raw?: string;
+    };
+};
+declare const _default$q: vue.DefineComponent<__VLS_Props$l, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$l> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLAnchorElement>;
+
+interface FootnoteNode {
+    type: 'footnote';
+    id: string;
+    children: {
+        type: string;
+        raw: string;
+    }[];
+    raw: string;
+}
+type __VLS_Props$k = {
+    node: FootnoteNode;
+    indexKey: string | number;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$p: vue.DefineComponent<__VLS_Props$k, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$k> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+interface FootnoteReferenceNode {
+    type: 'footnote_reference';
+    id: string;
+    raw: string;
+}
+type __VLS_Props$j = {
+    node: FootnoteReferenceNode;
+};
+declare const _default$o: vue.DefineComponent<__VLS_Props$j, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$j> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;
+
+interface HardBreakNode {
+    type: 'hardbreak';
+    raw: string;
+}
+type __VLS_Props$i = {
+    node: HardBreakNode;
+};
+declare const _default$n: vue.DefineComponent<__VLS_Props$i, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$i> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLBRElement>;
+
+declare const _HeadingNode: any;
+
+interface NodeChild$8 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$h = {
+    node: {
+        type: 'highlight';
+        children: NodeChild$8[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$m: vue.DefineComponent<__VLS_Props$h, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$h> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;
+
+type __VLS_Props$g = {
+    node: {
+        content: string;
+        raw?: string;
+        tag?: string;
+        attrs?: [string, string][] | null;
+        loading?: boolean;
+    };
+    customId?: string;
+};
+declare function __VLS_template$3(): {
+    attrs: Partial<{}>;
+    slots: {
+        placeholder?(_: {
+            node: {
+                content: string;
+                raw?: string;
+                tag?: string;
+                attrs?: [string, string][] | null;
+                loading?: boolean;
+            };
+        }): any;
+    };
+    refs: {
+        htmlRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult$3 = ReturnType<typeof __VLS_template$3>;
+declare const __VLS_component$3: vue.DefineComponent<__VLS_Props$g, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$g> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
+    htmlRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default$l: __VLS_WithTemplateSlots$3<typeof __VLS_component$3, __VLS_TemplateResult$3["slots"]>;
+
+type __VLS_WithTemplateSlots$3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+type __VLS_Props$f = {
+    node: {
+        type: 'html_inline';
+        tag?: string;
+        content: string;
+        loading?: boolean;
+        autoClosed?: boolean;
+    };
+    customId?: string;
+};
+declare const _default$k: vue.DefineComponent<__VLS_Props$f, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$f> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+
+declare function __VLS_template$2(): {
+    attrs: Partial<{}>;
+    slots: {
+        placeholder?(_: {
+            node: {
+                type: "image";
+                src: string;
+                alt: string;
+                title: string | null;
+                raw: string;
+                loading?: boolean;
+            };
+            displaySrc: string;
+            imageLoaded: boolean;
+            hasError: boolean;
+            fallbackSrc: string;
+            lazy: boolean;
+        }): any;
+        error?(_: {
+            node: {
+                type: "image";
+                src: string;
+                alt: string;
+                title: string | null;
+                raw: string;
+                loading?: boolean;
+            };
+            displaySrc: string;
+            imageLoaded: boolean;
+            hasError: true;
+            fallbackSrc: string;
+            lazy: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult$2 = ReturnType<typeof __VLS_template$2>;
+declare const __VLS_component$2: vue.DefineComponent<ImageNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {} & {
+    click: (payload: [Event, string]) => any;
+    error: (src: string) => any;
+    load: (src: string) => any;
+}, string, vue.PublicProps, Readonly<ImageNodeProps> & Readonly<{
+    onClick?: (payload: [Event, string]) => any;
+    onError?: (src: string) => any;
+    onLoad?: (src: string) => any;
+}>, {
+    fallbackSrc: string;
+    lazy: boolean;
+    usePlaceholder: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;
+declare const _default$j: __VLS_WithTemplateSlots$2<typeof __VLS_component$2, __VLS_TemplateResult$2["slots"]>;
+
+type __VLS_WithTemplateSlots$2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+type __VLS_Props$e = {
+    node: {
+        type: 'inline_code';
+        code: string;
+        raw: string;
+    };
+};
+declare const _default$i: vue.DefineComponent<__VLS_Props$e, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$e> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;
+
+interface NodeChild$7 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$d = {
+    node: {
+        type: 'insert';
+        children: NodeChild$7[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$h: vue.DefineComponent<__VLS_Props$d, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$d> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLModElement>;
+
+declare const _default$g: vue.DefineComponent<LinkNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<LinkNodeProps> & Readonly<{}>, {
+    showTooltip: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+
+interface NodeChild$6 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+interface ListItem$1 {
+    type: 'list_item';
+    children: NodeChild$6[];
+    raw: string;
+}
+type __VLS_Props$c = {
+    /**
+     * Preferred prop name for consistency with other node components.
+     * `item` is kept for backward compatibility.
+     */
+    node?: ListItem$1;
+    item?: ListItem$1;
+    indexKey?: number | string;
+    value?: number;
+    customId?: string;
+    /** Forwarded flag to enable/disable non-code node enter transition */
+    typewriter?: boolean;
+    showTooltips?: boolean;
+};
+declare const _default$f: vue.DefineComponent<__VLS_Props$c, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (text: string) => any;
+}, string, vue.PublicProps, Readonly<__VLS_Props$c> & Readonly<{
+    onCopy?: (text: string) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, HTMLLIElement>;
+
+interface NodeChild$5 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+interface ListItem {
+    type: 'list_item';
+    children: NodeChild$5[];
+    raw: string;
+}
+type __VLS_Props$b = {
+    node: {
+        type: 'list';
+        ordered: boolean;
+        start?: number;
+        items: ListItem[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+    typewriter?: boolean;
+    showTooltips?: boolean;
+};
+declare const _default$e: vue.DefineComponent<__VLS_Props$b, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$b> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+
+type __VLS_Props$a = {
+    node: {
+        type: 'code_block';
+        language: string;
+        code: string;
+        raw: string;
+        diff?: boolean;
+        originalCode?: string;
+        updatedCode?: string;
+    };
+    loading?: boolean;
+    /**
+     * If true, update and render code content as it streams in.
+     * If false, keep a lightweight loading state and create the editor only when loading becomes false.
+     */
+    stream?: boolean;
+    darkTheme?: string;
+    lightTheme?: string;
+    isDark?: boolean;
+    isShowPreview?: boolean;
+    enableFontSizeControl?: boolean;
+    /** Minimum width for the code block container (px or CSS unit string) */
+    minWidth?: string | number;
+    /** Maximum width for the code block container (px or CSS unit string) */
+    maxWidth?: string | number;
+    themes?: string[];
+    /** Header visibility and controls */
+    showHeader?: boolean;
+    showCopyButton?: boolean;
+    showExpandButton?: boolean;
+    showPreviewButton?: boolean;
+    showCollapseButton?: boolean;
+    showFontSizeButtons?: boolean;
+    /** Toggle singleton tooltips for header action buttons */
+    showTooltips?: boolean;
+    estimatedHeightPx?: number;
+    estimatedContentHeightPx?: number;
+};
+declare function __VLS_template$1(): {
+    attrs: Partial<{}>;
+    slots: {
+        'header-left'?(_: {}): any;
+        'header-right'?(_: {}): any;
+        loading?(_: {
+            loading: boolean;
+            stream: boolean;
+        }): any;
+    };
+    refs: {
+        container: HTMLDivElement;
+        codeBlockContent: HTMLDivElement;
+        rendererTarget: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult$1 = ReturnType<typeof __VLS_template$1>;
+declare const __VLS_component$1: vue.DefineComponent<__VLS_Props$a, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    previewCode: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$a> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+    onPreviewCode?: (...args: any[]) => any;
+}>, {
+    isDark: boolean;
+    loading: boolean;
+    stream: boolean;
+    darkTheme: string;
+    lightTheme: string;
+    isShowPreview: boolean;
+    enableFontSizeControl: boolean;
+    minWidth: string | number;
+    maxWidth: string | number;
+    showHeader: boolean;
+    showCopyButton: boolean;
+    showExpandButton: boolean;
+    showPreviewButton: boolean;
+    showCollapseButton: boolean;
+    showFontSizeButtons: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
+    container: HTMLDivElement;
+    codeBlockContent: HTMLDivElement;
+    rendererTarget: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default$d: __VLS_WithTemplateSlots$1<typeof __VLS_component$1, __VLS_TemplateResult$1["slots"]>;
+
+type __VLS_WithTemplateSlots$1<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+type KatexLoader = () => Promise<any> | any;
+declare function setKatexLoader(loader: KatexLoader | null): void;
+declare function enableKatex(loader?: KatexLoader): void;
+declare function disableKatex(): void;
+declare function isKatexEnabled(): boolean;
+
+type MermaidLoader = () => Promise<any> | any;
+declare function setMermaidLoader(loader: MermaidLoader | null): void;
+declare function enableMermaid(loader?: MermaidLoader): void;
+declare function disableMermaid(): void;
+declare function isMermaidEnabled(): boolean;
+
+type NodeRendererCodeBlockProps = Partial<Omit<CodeBlockNodeProps, 'node'>> & Record<string, unknown>;
+interface NodeRendererProps {
+    /** Raw Markdown input. Omit this when you pass pre-parsed nodes instead. */
+    content?: string;
+    /** Pre-parsed Markdown nodes to render without running the internal parser. */
+    nodes?: BaseNode[];
+    /**
+     * Whether the input stream is complete (end-of-stream). When true, the parser
+     * will stop emitting streaming "loading" nodes for unfinished constructs.
+     */
+    final?: boolean;
+    /** Options forwarded to parseMarkdownToStructure when content is provided */
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    /** Log parse/render timing and virtualization stats (dev only) */
+    debugPerformance?: boolean;
+    /**
+     * Custom HTML-like tags that participate in streaming mid-state handling
+     * and are emitted as custom nodes (e.g. ['thinking']). Forwarded to `getMarkdown()`.
+     */
+    customHtmlTags?: readonly string[];
+    /** Enable priority rendering for visible viewport area */
+    viewportPriority?: boolean;
+    /**
+     * Whether code_block renders should stream updates.
+     * When false, code blocks stay in a loading state and render once when final content is ready.
+     * Default: true
+     */
+    codeBlockStream?: boolean;
+    /** Preferred dark Monaco theme forwarded to every code block renderer. */
+    codeBlockDarkTheme?: CodeBlockMonacoTheme;
+    /** Preferred light Monaco theme forwarded to every code block renderer. */
+    codeBlockLightTheme?: CodeBlockMonacoTheme;
+    /** Monaco editor options forwarded to every `CodeBlockNode`. */
+    codeBlockMonacoOptions?: CodeBlockMonacoOptions;
+    /** If true, render all `code_block` nodes as plain <pre><code> blocks instead of the full CodeBlockNode */
+    renderCodeBlocksAsPre?: boolean;
+    /** Minimum width forwarded to CodeBlockNode (px or CSS unit) */
+    codeBlockMinWidth?: string | number;
+    /** Maximum width forwarded to CodeBlockNode (px or CSS unit) */
+    codeBlockMaxWidth?: string | number;
+    /** Arbitrary props to forward to every CodeBlockNode */
+    codeBlockProps?: NodeRendererCodeBlockProps;
+    /** Props forwarded to MermaidBlockNode for mermaid fences */
+    mermaidProps?: Partial<Omit<MermaidBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
+    /** Props forwarded to D2BlockNode for d2/d2lang fences */
+    d2Props?: Partial<Omit<D2BlockNodeProps, 'node' | 'loading' | 'isDark'>>;
+    /** Props forwarded to InfographicBlockNode for infographic fences */
+    infographicProps?: Partial<Omit<InfographicBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
+    /** Global tooltip toggle for link/code-block renderers (default: true) */
+    showTooltips?: boolean;
+    /** Theme names or theme objects preloaded for Monaco-backed code blocks. */
+    themes?: CodeBlockMonacoTheme[];
+    /** Forces dark mode for built-in renderers such as Mermaid, D2, KaTeX, and code blocks. */
+    isDark?: boolean;
+    /** Scope key used by `setCustomComponents()` and `data-custom-id` style overrides. */
+    customId?: string;
+    indexKey?: number | string;
+    /** Enable/disable the non-code-node enter transition (typewriter). Default: true */
+    typewriter?: boolean;
+    /** Enable incremental/batched rendering of nodes to avoid large single flush costs. Default: true */
+    batchRendering?: boolean;
+    /** How many nodes to render immediately before batching kicks in. Default: 40 */
+    initialRenderBatchSize?: number;
+    /** How many additional nodes to render per batch tick. Default: 80 */
+    renderBatchSize?: number;
+    /** Extra delay (ms) before each batch after rAF; helps yield to input. Default: 16 */
+    renderBatchDelay?: number;
+    /** Target budget (ms) for each batch before we shrink subsequent batch sizes. Default: 6 */
+    renderBatchBudgetMs?: number;
+    /** Timeout (ms) for requestIdleCallback slices. Default: 120 */
+    renderBatchIdleTimeoutMs?: number;
+    /** Defer rendering nodes until they are near the viewport */
+    deferNodesUntilVisible?: boolean;
+    /** Maximum number of fully rendered nodes kept in DOM. Default: 320 */
+    maxLiveNodes?: number;
+    /** Number of nodes to keep before/after focus. Default: 60 */
+    liveNodeBuffer?: number;
+}
+
+declare const _default$c: vue.DefineComponent<NodeRendererProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    handleArtifactClick: (...args: any[]) => void;
+    click: (...args: any[]) => void;
+    mouseover: (...args: any[]) => void;
+    mouseout: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<NodeRendererProps> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+    onHandleArtifactClick?: (...args: any[]) => any;
+    onClick?: (...args: any[]) => any;
+    onMouseover?: (...args: any[]) => any;
+    onMouseout?: (...args: any[]) => any;
+}>, {
+    showTooltips: boolean;
+    typewriter: boolean;
+    codeBlockStream: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {
+    containerRef: HTMLDivElement;
+    paragraphProbeWrapperRef: HTMLDivElement;
+    listItemProbeWrapperRef: HTMLDivElement;
+    listProbeWrapperRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+interface NodeChild$4 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$9 = {
+    node: {
+        type: 'paragraph';
+        children: NodeChild$4[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+    customHtmlTags?: readonly string[];
+};
+declare const _default$b: vue.DefineComponent<__VLS_Props$9, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$9> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLParagraphElement>;
+
+declare const _default$a: vue.DefineComponent<PreCodeNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<PreCodeNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLPreElement>;
+
+type __VLS_Props$8 = {
+    node: {
+        type: 'reference';
+        id: string;
+        raw: string;
+    };
+    messageId?: string;
+    threadId?: string;
+};
+declare const _default$9: vue.DefineComponent<__VLS_Props$8, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+    mouseEnter: (...args: any[]) => void;
+    mouseLeave: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$8> & Readonly<{
+    onClick?: (...args: any[]) => any;
+    onMouseEnter?: (...args: any[]) => any;
+    onMouseLeave?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;
+
+interface NodeChild$3 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$7 = {
+    node: {
+        type: 'strikethrough';
+        children: NodeChild$3[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: string | number;
+};
+declare const _default$8: vue.DefineComponent<__VLS_Props$7, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$7> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLModElement>;
+
+interface NodeChild$2 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$6 = {
+    node: {
+        type: 'strong';
+        children: NodeChild$2[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$7: vue.DefineComponent<__VLS_Props$6, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$6> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;
+
+interface NodeChild$1 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$5 = {
+    node: {
+        type: 'subscript';
+        children: NodeChild$1[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$6: vue.DefineComponent<__VLS_Props$5, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$5> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;
+
+interface NodeChild {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$4 = {
+    node: {
+        type: 'superscript';
+        children: NodeChild[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$5: vue.DefineComponent<__VLS_Props$4, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$4> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLElement>;
+
+interface TableCellNode {
+    type: 'table_cell';
+    header: boolean;
+    children: {
+        type: string;
+        raw: string;
+    }[];
+    raw: string;
+    align?: 'left' | 'right' | 'center';
+}
+interface TableRowNode {
+    type: 'table_row';
+    cells: TableCellNode[];
+    raw: string;
+}
+interface TableNode {
+    type: 'table';
+    header: TableRowNode;
+    rows: TableRowNode[];
+    raw: string;
+    loading: boolean;
+}
+type __VLS_Props$3 = {
+    node: TableNode;
+    indexKey: string | number;
+    isDark?: boolean;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        loading?(_: {
+            isLoading: true;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: vue.DefineComponent<__VLS_Props$3, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$3> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default$4: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+type __VLS_Props$2 = {
+    node: {
+        type: 'text';
+        content: string;
+        raw: string;
+        center?: boolean;
+    };
+};
+declare const _default$3: vue.DefineComponent<__VLS_Props$2, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<__VLS_Props$2> & Readonly<{
+    onCopy?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLSpanElement>;
+
+declare const _default$2: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, HTMLHRElement>;
+
+type __VLS_Props$1 = {
+    visible: boolean;
+    anchorEl: HTMLElement | null;
+    content: string;
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    offset?: number;
+    originX?: number | null;
+    originY?: number | null;
+    id?: string | null;
+    /** @deprecated Dark mode is now handled via semantic CSS tokens. */
+    isDark?: boolean | null;
+};
+declare const _default$1: vue.DefineComponent<__VLS_Props$1, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$1> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
+    tooltip: HTMLDivElement;
+    arrowEl: HTMLDivElement;
+}, any>;
+
+interface VmrContainerNode {
+    type: 'vmr_container';
+    name: string;
+    loading?: boolean;
+    attrs?: Record<string, string>;
+    children: {
+        type: string;
+        raw: string;
+    }[];
+    raw: string;
+}
+type __VLS_Props = {
+    node: VmrContainerNode;
+    indexKey: number | string;
+    isDark?: boolean;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default: vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const defaultMap: Record<string, string>;
+/**
+ * Replace the entire default translation map.
+ * Consumers can call this to provide their own fallback translations (e.g. Chinese).
+ */
+declare function setDefaultI18nMap(map: Record<keyof typeof defaultMap, string>): void;
+
+declare function setCustomComponents(id: string, mapping: Partial<CustomComponents$1>): void;
+declare function setCustomComponents(mapping: Partial<CustomComponents$1>): void;
+/**
+ * Retrieve custom components for a given scope id.
+ * If no id is provided, returns the legacy/global mapping (if any).
+ */
+declare function getCustomNodeComponents(customId?: string): Partial<CustomComponents$1>;
+/**
+ * Remove a scoped custom components mapping.
+ * Use this to clean up mappings for dynamic or temporary renderers.
+ */
+declare function removeCustomComponents(id: string): void;
+/**
+ * Clear the legacy/global custom components mapping.
+ * Use this when you want to remove the single-argument mapping set by
+ * `setCustomComponents(mapping)`.
+ */
+declare function clearGlobalCustomComponents(): void;
+
+interface MonacoDisposableLike {
+    dispose?: () => void;
+}
+interface MonacoModelLike {
+    getLineCount?: () => number;
+}
+interface MonacoEditorViewLike {
+    getModel?: () => MonacoModelLike | null | undefined;
+    getOption?: (option: unknown) => unknown;
+    updateOptions?: (options: Record<string, unknown>) => void;
+    layout?: () => void;
+    getContentHeight?: () => number;
+    onDidContentSizeChange?: (listener: () => void) => MonacoDisposableLike | void;
+    onDidLayoutChange?: (listener: () => void) => MonacoDisposableLike | void;
+}
+interface MonacoDiffLineChangeLike {
+    originalStartLineNumber?: number;
+    originalEndLineNumber?: number;
+    modifiedStartLineNumber?: number;
+    modifiedEndLineNumber?: number;
+}
+interface MonacoDiffEditorViewLike extends MonacoEditorViewLike {
+    getOriginalEditor?: () => MonacoEditorViewLike | null | undefined;
+    getModifiedEditor?: () => MonacoEditorViewLike | null | undefined;
+    getLineChanges?: () => MonacoDiffLineChangeLike[] | null | undefined;
+    onDidUpdateDiff?: (listener: () => void) => MonacoDisposableLike | void;
+}
+interface MonacoNamespaceLike {
+    EditorOption?: {
+        fontInfo?: unknown;
+        lineHeight?: unknown;
+    };
+}
+interface MonacoRuntimeOptions extends Omit<CodeBlockMonacoOptions, 'theme'> {
+    theme?: CodeBlockMonacoTheme;
+    themes?: CodeBlockMonacoTheme[];
+    onThemeChange?: () => void;
+}
+interface MonacoHelpers {
+    createEditor?: (container: HTMLElement, code: string, language: string) => Promise<unknown> | unknown;
+    createDiffEditor?: (container: HTMLElement, original: string, modified: string, language: string) => Promise<unknown> | unknown;
+    updateCode?: (code: string, language: string) => Promise<unknown> | unknown;
+    updateDiff?: (original: string, modified: string, language: string) => Promise<unknown> | unknown;
+    getEditor?: () => MonacoNamespaceLike | null;
+    getEditorView?: () => MonacoEditorViewLike | null;
+    getDiffEditorView?: () => MonacoDiffEditorViewLike | null;
+    cleanupEditor?: () => void;
+    safeClean?: () => void;
+    refreshDiffPresentation?: () => void;
+    setTheme?: (theme: CodeBlockMonacoTheme | undefined) => Promise<void> | void;
+}
+interface MonacoModule {
+    useMonaco?: (options: MonacoRuntimeOptions) => MonacoHelpers | null | undefined;
+    detectLanguage?: (code: string) => string;
+}
+declare function getUseMonaco(): Promise<MonacoModule | null>;
+
+/**
+ * Recommend when to use Worker based on formula count and complexity.
+ *
+ * N_threshold ≈ floor(B / (R × (1 - H)))
+ * - B: main-thread budget (ms), e.g. 50ms or a stricter 16.7ms
+ * - R: avg render time per unique formula (ms)
+ * - H: cache hit rate (0~1)
+ */
+interface ThresholdInput {
+    R: number;
+    H?: number;
+    B?: number;
+}
+declare function recommendWorkerThreshold({ R, H, B }: ThresholdInput): number;
+declare function estimateRByFormula(sample: string): 'simple' | 'medium' | 'complex';
+declare function defaultRByClass(cls: 'simple' | 'medium' | 'complex'): number;
+declare function recommendNForSamples(formulas: string[], opts?: {
+    H?: number;
+    B?: number;
+}): number;
+
+type LanguageIconResolver = (lang: string) => string | undefined | null;
+declare const languageIconsRevision: vue.ShallowRef<number, number>;
+declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
+declare function normalizeLanguageIdentifier(lang?: string | null): string;
+declare function resolveMonacoLanguageId(lang?: string | null): string;
+declare function preloadExtendedLanguageIcons(): Promise<void>;
+declare function getLanguageIcon(lang: string): string;
+declare const languageMap: Record<string, string>;
+
+type LanguageIconMap = Record<string, string>;
+interface IconTheme {
+    /** Unique identifier, e.g. 'default', 'material' */
+    readonly id: string;
+    /** Core icons — statically imported, always available */
+    readonly core: LanguageIconMap;
+    /** Default/fallback icon SVG string */
+    readonly fallback: string;
+    /** Lazy loader for extended icons. Called at most once; result is cached. */
+    loadExtended?: () => Promise<LanguageIconMap>;
+}
+
+declare function registerIconTheme(theme: IconTheme): void;
+declare function setIconTheme(id: string): void;
+declare function getRegisteredThemes(): string[];
+
+/**
+ * Performance monitoring utility for KaTeX rendering
+ * Helps determine if Worker is beneficial in production
+ */
+interface RenderMetrics {
+    type: 'worker' | 'direct' | 'cache-hit';
+    duration: number;
+    formulaLength: number;
+    timestamp: number;
+    success: boolean;
+    error?: string;
+}
+declare class PerformanceMonitor {
+    private metrics;
+    private enabled;
+    private maxMetrics;
+    enable(): void;
+    disable(): void;
+    recordRender(metrics: RenderMetrics): void;
+    getStats(): {
+        totalRenders: number;
+        cacheHitRate: number;
+        averageWorkerTime: number;
+        averageDirectTime: number;
+        averageCacheHitTime: number;
+        workerSavings: number;
+        recommendation: string;
+        cacheHits?: undefined;
+        workerCalls?: undefined;
+        directCalls?: undefined;
+    } | {
+        totalRenders: number;
+        cacheHits: number;
+        cacheHitRate: string;
+        workerCalls: number;
+        directCalls: number;
+        averageWorkerTime: string;
+        averageDirectTime: string;
+        averageCacheHitTime: string;
+        workerSavings: string;
+        recommendation: string;
+    };
+    printReport(): {
+        totalRenders: number;
+        cacheHitRate: number;
+        averageWorkerTime: number;
+        averageDirectTime: number;
+        averageCacheHitTime: number;
+        workerSavings: number;
+        recommendation: string;
+        cacheHits?: undefined;
+        workerCalls?: undefined;
+        directCalls?: undefined;
+    } | {
+        totalRenders: number;
+        cacheHits: number;
+        cacheHitRate: string;
+        workerCalls: number;
+        directCalls: number;
+        averageWorkerTime: string;
+        averageDirectTime: string;
+        averageCacheHitTime: string;
+        workerSavings: string;
+        recommendation: string;
+    };
+    reset(): void;
+    exportMetrics(): {
+        metrics: RenderMetrics[];
+        stats: {
+            totalRenders: number;
+            cacheHitRate: number;
+            averageWorkerTime: number;
+            averageDirectTime: number;
+            averageCacheHitTime: number;
+            workerSavings: number;
+            recommendation: string;
+            cacheHits?: undefined;
+            workerCalls?: undefined;
+            directCalls?: undefined;
+        } | {
+            totalRenders: number;
+            cacheHits: number;
+            cacheHitRate: string;
+            workerCalls: number;
+            directCalls: number;
+            averageWorkerTime: string;
+            averageDirectTime: string;
+            averageCacheHitTime: string;
+            workerSavings: string;
+            recommendation: string;
+        };
+        timestamp: number;
+    };
+}
+declare const perfMonitor: PerformanceMonitor;
+declare function enablePerfMonitoring(): void;
+declare function disablePerfMonitoring(): void;
+declare function getPerfReport(): {
+    totalRenders: number;
+    cacheHitRate: number;
+    averageWorkerTime: number;
+    averageDirectTime: number;
+    averageCacheHitTime: number;
+    workerSavings: number;
+    recommendation: string;
+    cacheHits?: undefined;
+    workerCalls?: undefined;
+    directCalls?: undefined;
+} | {
+    totalRenders: number;
+    cacheHits: number;
+    cacheHitRate: string;
+    workerCalls: number;
+    directCalls: number;
+    averageWorkerTime: string;
+    averageDirectTime: string;
+    averageCacheHitTime: string;
+    workerSavings: string;
+    recommendation: string;
+};
+
+declare function safeRaf(cb: FrameRequestCallback): any;
+declare function safeCancelRaf(id: number | null): void;
+
+type KaTeXCDNWorkerMode = 'classic' | 'module';
+interface KaTeXCDNWorkerOptions {
+    /**
+     * Where to load KaTeX from inside the worker.
+     * - classic mode: UMD build (used via importScripts)
+     * - module mode: ESM build (used via dynamic import(url))
+     */
+    katexUrl: string;
+    /**
+     * Optional mhchem plugin URL to load in the worker (recommended).
+     * - classic mode: UMD build (importScripts)
+     * - module mode: ESM build (dynamic import(url))
+     */
+    mhchemUrl?: string;
+    /**
+     * - classic: widest compatibility, uses importScripts()
+     * - module: requires { type: 'module' } workers, uses import(url)
+     */
+    mode?: KaTeXCDNWorkerMode;
+    /**
+     * If set, worker prints verbose logs.
+     */
+    debug?: boolean;
+    /**
+     * Worker constructor options (name/type/credentials).
+     * Note: for module mode you should pass { type: 'module' }.
+     */
+    workerOptions?: WorkerOptions;
+    /**
+     * KaTeX render options used in the worker.
+     * Keep this minimal and stable for caching and predictable output.
+     */
+    renderOptions?: {
+        throwOnError?: boolean;
+        output?: string;
+        strict?: string;
+    };
+}
+interface KaTeXCDNWorkerHandle {
+    worker: Worker | null;
+    /**
+     * Revoke the generated Blob URL. Call this when you no longer need the worker.
+     * This does not terminate the worker automatically.
+     */
+    dispose: () => void;
+    /**
+     * The generated worker source code (useful for debugging/tests).
+     */
+    source: string;
+}
+declare function buildKaTeXCDNWorkerSource(options: KaTeXCDNWorkerOptions): string;
+declare function createKaTeXWorkerFromCDN(options: KaTeXCDNWorkerOptions): KaTeXCDNWorkerHandle;
+
+/**
+ * Allow user to inject a Worker instance, e.g. from Vite ?worker import.
+ */
+declare function setKaTeXWorker(w: Worker): void;
+/**
+ * Remove the current worker instance (for cleanup or SSR).
+ */
+declare function clearKaTeXWorker(): void;
+declare function setKaTeXWorkerDebug(enabled: boolean): void;
+declare function renderKaTeXInWorker(content: string, displayMode?: boolean, timeout?: number, signal?: AbortSignal): Promise<string>;
+declare function setKaTeXCache(content: string, displayMode: boolean, html: string): void;
+/**
+ * Utilities for clients to inspect/adjust worker load behavior
+ */
+declare function getKaTeXWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+declare function setKaTeXWorkerMaxConcurrency(n: number): void;
+declare const WORKER_BUSY_CODE = "WORKER_BUSY";
+declare function isKaTeXWorkerBusy(): boolean;
+declare function waitForKaTeXWorkerSlot(timeout?: number, signal?: AbortSignal): Promise<void>;
+interface BackpressureOptions {
+    timeout?: number;
+    waitTimeout?: number;
+    backoffMs?: number;
+    maxRetries?: number;
+    signal?: AbortSignal;
+}
+declare const defaultBackpressure: {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+declare function setKaTeXBackpressureDefaults(opts: Partial<typeof defaultBackpressure>): void;
+declare function getKaTeXBackpressureDefaults(): {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+/**
+ * Convenience wrapper: when worker reports busy, wait for a slot and retry.
+ * Does not implement fallback-to-main-thread; leave that to the caller.
+ */
+declare function renderKaTeXWithBackpressure(content: string, displayMode?: boolean, opts?: BackpressureOptions): Promise<string>;
+
+type MermaidCDNWorkerMode = 'classic' | 'module';
+interface MermaidCDNWorkerOptions {
+    /**
+     * Where to load mermaid from inside the worker.
+     * - classic mode: non-module build (used via importScripts)
+     * - module mode: ESM build (used via dynamic import(url))
+     */
+    mermaidUrl: string;
+    /**
+     * - classic: widest compatibility, uses importScripts()
+     * - module: requires { type: 'module' } workers, uses import(url)
+     */
+    mode?: MermaidCDNWorkerMode;
+    /**
+     * If set, worker prints verbose logs.
+     */
+    debug?: boolean;
+    /**
+     * Worker constructor options (name/type/credentials).
+     * Note: for module mode you should pass { type: 'module' }.
+     */
+    workerOptions?: WorkerOptions;
+    /**
+     * Mermaid initialize options used in the worker.
+     * This worker is used for parsing only; keep options minimal.
+     */
+    initializeOptions?: Record<string, any>;
+}
+interface MermaidCDNWorkerHandle {
+    worker: Worker | null;
+    dispose: () => void;
+    source: string;
+}
+declare function buildMermaidCDNWorkerSource(options: MermaidCDNWorkerOptions): string;
+declare function createMermaidWorkerFromCDN(options: MermaidCDNWorkerOptions): MermaidCDNWorkerHandle;
+
+type Theme = 'light' | 'dark';
+declare function setMermaidWorkerClientDebug(enabled: boolean): void;
+declare function setMermaidWorkerMaxConcurrency(n: number): void;
+declare function getMermaidWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+declare const MERMAID_WORKER_BUSY_CODE = "WORKER_BUSY";
+declare const MERMAID_DISABLED_CODE = "MERMAID_DISABLED";
+/**
+ * Allow user to inject a Worker instance, e.g. from Vite ?worker import.
+ */
+declare function setMermaidWorker(w: Worker): void;
+/**
+ * Remove the current worker instance (for cleanup or SSR).
+ */
+declare function clearMermaidWorker(): void;
+declare function canParseOffthread(code: string, theme: Theme, timeout?: number): Promise<boolean>;
+declare function findPrefixOffthread(code: string, theme: Theme, timeout?: number): Promise<string>;
+declare function terminateWorker(): void;
+
 declare const CodeBlockNode: {
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types/types/component-props').CodeBlockNodeProps & {
+    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<CodeBlockNodeProps & {
         estimatedHeightPx?: number;
         estimatedContentHeightPx?: number;
     }> & Readonly<{
         onCopy?: (...args: any[]) => any;
         onPreviewCode?: (...args: any[]) => any;
-    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    }>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
         copy: (...args: any[]) => void;
         previewCode: (...args: any[]) => void;
-    }, import('vue').PublicProps, {
+    }, vue.PublicProps, {
         isDark: boolean;
         loading: boolean;
         stream: boolean;
-        darkTheme: import('./types/types/component-props').CodeBlockMonacoTheme;
-        lightTheme: import('./types/types/component-props').CodeBlockMonacoTheme;
+        darkTheme: CodeBlockMonacoTheme;
+        lightTheme: CodeBlockMonacoTheme;
         isShowPreview: boolean;
         enableFontSizeControl: boolean;
         minWidth: string | number;
@@ -65,17 +1612,17 @@ declare const CodeBlockNode: {
         showPreviewButton: boolean;
         showCollapseButton: boolean;
         showFontSizeButtons: boolean;
-    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+    }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
         container: HTMLDivElement;
         codeEditor: HTMLDivElement;
-    }, any, import('vue').ComponentProvideOptions, {
+    }, any, vue.ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('./types/types/component-props').CodeBlockNodeProps & {
+    }, Readonly<CodeBlockNodeProps & {
         estimatedHeightPx?: number;
         estimatedContentHeightPx?: number;
     }> & Readonly<{
@@ -85,8 +1632,8 @@ declare const CodeBlockNode: {
         isDark: boolean;
         loading: boolean;
         stream: boolean;
-        darkTheme: import('./types/types/component-props').CodeBlockMonacoTheme;
-        lightTheme: import('./types/types/component-props').CodeBlockMonacoTheme;
+        darkTheme: CodeBlockMonacoTheme;
+        lightTheme: CodeBlockMonacoTheme;
         isShowPreview: boolean;
         enableFontSizeControl: boolean;
         minWidth: string | number;
@@ -101,21 +1648,21 @@ declare const CodeBlockNode: {
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import('vue').ComponentOptionsBase<Readonly<import('./types/types/component-props').CodeBlockNodeProps & {
+} & vue.ComponentOptionsBase<Readonly<CodeBlockNodeProps & {
     estimatedHeightPx?: number;
     estimatedContentHeightPx?: number;
 }> & Readonly<{
     onCopy?: (...args: any[]) => any;
     onPreviewCode?: (...args: any[]) => any;
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     copy: (...args: any[]) => void;
     previewCode: (...args: any[]) => void;
 }, string, {
     isDark: boolean;
     loading: boolean;
     stream: boolean;
-    darkTheme: import('./types/types/component-props').CodeBlockMonacoTheme;
-    lightTheme: import('./types/types/component-props').CodeBlockMonacoTheme;
+    darkTheme: CodeBlockMonacoTheme;
+    lightTheme: CodeBlockMonacoTheme;
     isShowPreview: boolean;
     enableFontSizeControl: boolean;
     minWidth: string | number;
@@ -126,7 +1673,7 @@ declare const CodeBlockNode: {
     showPreviewButton: boolean;
     showCollapseButton: boolean;
     showFontSizeButtons: boolean;
-}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
     $slots: {
         'header-left'?(_: {}): any;
         'header-right'?(_: {}): any;
@@ -136,24 +1683,24 @@ declare const CodeBlockNode: {
         }): any;
     };
 });
-declare const MathBlockNode: import('vue').DefineComponent<import('./types/types/component-props').MathBlockNodeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./types/types/component-props').MathBlockNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+declare const MathBlockNode: vue.DefineComponent<MathBlockNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<MathBlockNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
     containerEl: HTMLDivElement;
 }, HTMLDivElement>;
 declare const MathInlineNode: {
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types/types/component-props').MathInlineNodeProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<MathInlineNodeProps> & Readonly<{}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {}, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
         containerEl: HTMLSpanElement;
-    }, HTMLSpanElement, import('vue').ComponentProvideOptions, {
+    }, HTMLSpanElement, vue.ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('./types/types/component-props').MathInlineNodeProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    }, Readonly<MathInlineNodeProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import('vue').ComponentOptionsBase<Readonly<import('./types/types/component-props').MathInlineNodeProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+} & vue.ComponentOptionsBase<Readonly<MathInlineNodeProps> & Readonly<{}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
     $slots: {
         loading?(_: {
             isLoading: true;
@@ -161,17 +1708,17 @@ declare const MathInlineNode: {
     };
 });
 declare const MermaidBlockNode: {
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types/types/component-props').MermaidBlockNodeProps> & Readonly<{
+    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<MermaidBlockNodeProps> & Readonly<{
         onCopy?: (...args: any[]) => any;
         onExport?: (...args: any[]) => any;
         onOpenModal?: (...args: any[]) => any;
         onToggleMode?: (...args: any[]) => any;
-    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    }>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
         copy: (...args: any[]) => void;
         export: (...args: any[]) => void;
         openModal: (...args: any[]) => void;
         toggleMode: (...args: any[]) => void;
-    }, import('vue').PublicProps, {
+    }, vue.PublicProps, {
         loading: boolean;
         showHeader: boolean;
         showCopyButton: boolean;
@@ -193,19 +1740,19 @@ declare const MermaidBlockNode: {
         showZoomControls: boolean;
         enableWheelZoom: boolean;
         isStrict: boolean;
-    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+    }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
         modeContainerRef: HTMLDivElement;
         mermaidContainer: HTMLDivElement;
         mermaidContent: HTMLDivElement;
         modalContent: HTMLDivElement;
-    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+    }, HTMLDivElement, vue.ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('./types/types/component-props').MermaidBlockNodeProps> & Readonly<{
+    }, Readonly<MermaidBlockNodeProps> & Readonly<{
         onCopy?: (...args: any[]) => any;
         onExport?: (...args: any[]) => any;
         onOpenModal?: (...args: any[]) => any;
@@ -236,12 +1783,12 @@ declare const MermaidBlockNode: {
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import('vue').ComponentOptionsBase<Readonly<import('./types/types/component-props').MermaidBlockNodeProps> & Readonly<{
+} & vue.ComponentOptionsBase<Readonly<MermaidBlockNodeProps> & Readonly<{
     onCopy?: (...args: any[]) => any;
     onExport?: (...args: any[]) => any;
     onOpenModal?: (...args: any[]) => any;
     onToggleMode?: (...args: any[]) => any;
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     copy: (...args: any[]) => void;
     export: (...args: any[]) => void;
     openModal: (...args: any[]) => void;
@@ -268,7 +1815,7 @@ declare const MermaidBlockNode: {
     showZoomControls: boolean;
     enableWheelZoom: boolean;
     isStrict: boolean;
-}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
     $slots: {
         'header-left'?(_: {}): any;
         'header-center'?(_: {}): any;
@@ -276,15 +1823,15 @@ declare const MermaidBlockNode: {
     };
 });
 declare const InfographicBlockNode: {
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types/types/component-props').InfographicBlockNodeProps> & Readonly<{
+    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<InfographicBlockNodeProps> & Readonly<{
         onCopy?: (...args: any[]) => any;
         onExport?: (...args: any[]) => any;
         onOpenModal?: (...args: any[]) => any;
-    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    }>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
         copy: (...args: any[]) => void;
         export: (...args: any[]) => void;
         openModal: (...args: any[]) => void;
-    }, import('vue').PublicProps, {
+    }, vue.PublicProps, {
         loading: boolean;
         showHeader: boolean;
         showCopyButton: boolean;
@@ -294,18 +1841,18 @@ declare const InfographicBlockNode: {
         showExportButton: boolean;
         showFullscreenButton: boolean;
         showZoomControls: boolean;
-    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+    }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
         viewportTarget: HTMLDivElement;
         infographicContainer: HTMLDivElement;
         modalContent: HTMLDivElement;
-    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+    }, HTMLDivElement, vue.ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('./types/types/component-props').InfographicBlockNodeProps> & Readonly<{
+    }, Readonly<InfographicBlockNodeProps> & Readonly<{
         onCopy?: (...args: any[]) => any;
         onExport?: (...args: any[]) => any;
         onOpenModal?: (...args: any[]) => any;
@@ -323,11 +1870,11 @@ declare const InfographicBlockNode: {
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import('vue').ComponentOptionsBase<Readonly<import('./types/types/component-props').InfographicBlockNodeProps> & Readonly<{
+} & vue.ComponentOptionsBase<Readonly<InfographicBlockNodeProps> & Readonly<{
     onCopy?: (...args: any[]) => any;
     onExport?: (...args: any[]) => any;
     onOpenModal?: (...args: any[]) => any;
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     copy: (...args: any[]) => void;
     export: (...args: any[]) => void;
     openModal: (...args: any[]) => void;
@@ -341,14 +1888,14 @@ declare const InfographicBlockNode: {
     showExportButton: boolean;
     showFullscreenButton: boolean;
     showZoomControls: boolean;
-}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
     $slots: {
         'header-left'?(_: {}): any;
         'header-center'?(_: {}): any;
         'header-right'?(_: {}): any;
     };
 });
-declare const D2BlockNode: import('vue').DefineComponent<import('./types/types/component-props').D2BlockNodeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./types/types/component-props').D2BlockNodeProps> & Readonly<{}>, {
+declare const D2BlockNode: vue.DefineComponent<D2BlockNodeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<D2BlockNodeProps> & Readonly<{}>, {
     loading: boolean;
     showHeader: boolean;
     showCopyButton: boolean;
@@ -358,24 +1905,14 @@ declare const D2BlockNode: import('vue').DefineComponent<import('./types/types/c
     showExportButton: boolean;
     progressiveRender: boolean;
     progressiveIntervalMs: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
     viewportTarget: HTMLDivElement;
     bodyRef: HTMLDivElement;
 }, HTMLDivElement>;
-export type { D2Loader } from './types/components/D2BlockNode/d2';
-export type { KatexLoader } from './types/components/MathInlineNode/katex';
-export type { MermaidLoader } from './types/components/MermaidBlockNode/mermaid';
-export type { CodeBlockDiffAppearance, CodeBlockDiffHideUnchangedRegions, CodeBlockDiffHideUnchangedRegionsOptions, CodeBlockDiffHunkActionContext, CodeBlockDiffHunkActionKind, CodeBlockDiffHunkSide, CodeBlockDiffLineStyle, CodeBlockDiffUnchangedRegionStyle, CodeBlockMonacoLanguage, CodeBlockMonacoOptions, CodeBlockMonacoTheme, CodeBlockMonacoThemeObject, CodeBlockNodeProps, D2BlockNodeProps, ImageNodeProps, InfographicBlockNodeProps, LinkNodeProps, MathBlockNodeProps, MathInlineNodeProps, MermaidBlockEvent, MermaidBlockNodeProps, PreCodeNodeProps, } from './types/types/component-props';
-export type { NodeRendererProps } from './types/types/node-renderer-props';
-export * from './types/utils';
-export * from './types/workers/katexCdnWorker';
-export * from './types/workers/katexWorkerClient';
-export * from './types/workers/mermaidCdnWorker';
-export * from './types/workers/mermaidWorkerClient';
-export { KATEX_COMMANDS, normalizeStandaloneBackslashT, setDefaultMathOptions } from 'stream-markdown-parser';
-export type { MathOptions } from 'stream-markdown-parser';
-export interface CustomComponents extends MarkstreamCustomComponents {
-}
-export { AdmonitionNode, BlockquoteNode, CheckboxNode, clearGlobalCustomComponents, CodeBlockNode, D2BlockNode, DefinitionListNode, disableD2, disableKatex, disableMermaid, EmojiNode, EmphasisNode, enableD2, enableKatex, enableMermaid, FootnoteAnchorNode, FootnoteNode, FootnoteReferenceNode, getCustomNodeComponents, HardBreakNode, HeadingNode, HighlightNode, HtmlBlockNode, HtmlInlineNode, ImageNode, InfographicBlockNode, InlineCodeNode, InsertNode, isD2Enabled, isKatexEnabled, isMermaidEnabled, LinkNode, ListItemNode, ListNode, MarkdownCodeBlockNode, MarkdownRender, MathBlockNode, MathInlineNode, MermaidBlockNode, ParagraphNode, PreCodeNode, ReferenceNode, removeCustomComponents, setCustomComponents, setD2Loader, setDefaultI18nMap, setKatexLoader, setMermaidLoader, StrikethroughNode, StrongNode, SubscriptNode, SuperscriptNode, TableNode, TextNode, ThematicBreakNode, Tooltip, VmrContainerNode, };
-export default MarkdownRender;
-export declare const VueRendererMarkdown: Plugin;
+
+interface CustomComponents extends CustomComponents$1 {
+}
+
+declare const VueRendererMarkdown: Plugin;
+
+export { _default$w as AdmonitionNode, BackpressureOptions, _default$v as BlockquoteNode, _default$u as CheckboxNode, CodeBlockDiffAppearance, CodeBlockDiffHideUnchangedRegions, CodeBlockDiffHideUnchangedRegionsOptions, CodeBlockDiffHunkActionContext, CodeBlockDiffHunkActionKind, CodeBlockDiffHunkSide, CodeBlockDiffLineStyle, CodeBlockDiffUnchangedRegionStyle, CodeBlockMonacoLanguage, CodeBlockMonacoOptions, CodeBlockMonacoTheme, CodeBlockMonacoThemeObject, CodeBlockNode, CodeBlockNodeProps, CodeBlockThemeProp, CustomComponents, D2BlockNode, D2BlockNodeProps, D2Loader, _default$t as DefinitionListNode, _default$s as EmojiNode, _default$r as EmphasisNode, _default$q as FootnoteAnchorNode, _default$p as FootnoteNode, _default$o as FootnoteReferenceNode, _default$n as HardBreakNode, _HeadingNode as HeadingNode, _default$m as HighlightNode, _default$l as HtmlBlockNode, _default$k as HtmlInlineNode, IconTheme, _default$j as ImageNode, ImageNodeProps, InfographicBlockNode, InfographicBlockNodeProps, _default$i as InlineCodeNode, _default$h as InsertNode, KaTeXCDNWorkerHandle, KaTeXCDNWorkerMode, KaTeXCDNWorkerOptions, KatexLoader, LanguageIconResolver, _default$g as LinkNode, LinkNodeProps, _default$f as ListItemNode, _default$e as ListNode, MERMAID_DISABLED_CODE, MERMAID_WORKER_BUSY_CODE, _default$d as MarkdownCodeBlockNode, _default$c as MarkdownRender, MathBlockNode, MathBlockNodeProps, MathInlineNode, MathInlineNodeProps, MermaidBlockEvent, MermaidBlockNode, MermaidBlockNodeProps, MermaidCDNWorkerHandle, MermaidCDNWorkerMode, MermaidCDNWorkerOptions, MermaidLoader, MonacoDiffEditorViewLike, MonacoDiffLineChangeLike, MonacoDisposableLike, MonacoEditorViewLike, MonacoHelpers, MonacoModelLike, MonacoModule, MonacoNamespaceLike, MonacoRuntimeOptions, NodeRendererProps, _default$b as ParagraphNode, _default$a as PreCodeNode, PreCodeNodeProps, _default$9 as ReferenceNode, _default$8 as StrikethroughNode, _default$7 as StrongNode, _default$6 as SubscriptNode, _default$5 as SuperscriptNode, _default$4 as TableNode, _default$3 as TextNode, _default$2 as ThematicBreakNode, ThresholdInput, _default$1 as Tooltip, _default as VmrContainerNode, VueRendererMarkdown, WORKER_BUSY_CODE, buildKaTeXCDNWorkerSource, buildMermaidCDNWorkerSource, canParseOffthread, clearGlobalCustomComponents, clearKaTeXWorker, clearMermaidWorker, createKaTeXWorkerFromCDN, createMermaidWorkerFromCDN, _default$c as default, defaultRByClass, disableD2, disableKatex, disableMermaid, disablePerfMonitoring, enableD2, enableKatex, enableMermaid, enablePerfMonitoring, estimateRByFormula, findPrefixOffthread, getCustomNodeComponents, getKaTeXBackpressureDefaults, getKaTeXWorkerLoad, getLanguageIcon, getMermaidWorkerLoad, getPerfReport, getRegisteredThemes, getUseMonaco, isD2Enabled, isKaTeXWorkerBusy, isKatexEnabled, isMermaidEnabled, languageIconsRevision, languageMap, normalizeLanguageIdentifier, perfMonitor, preloadExtendedLanguageIcons, recommendNForSamples, recommendWorkerThreshold, registerIconTheme, removeCustomComponents, renderKaTeXInWorker, renderKaTeXWithBackpressure, resolveMonacoLanguageId, safeCancelRaf, safeRaf, setCustomComponents, setD2Loader, setDefaultI18nMap, setIconTheme, setKaTeXBackpressureDefaults, setKaTeXCache, setKaTeXWorker, setKaTeXWorkerDebug, setKaTeXWorkerMaxConcurrency, setKatexLoader, setLanguageIconResolver, setMermaidLoader, setMermaidWorker, setMermaidWorkerClientDebug, setMermaidWorkerMaxConcurrency, terminateWorker, waitForKaTeXWorkerSlot };