markstream-vue2 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1742 @@
+import * as vue from 'vue';
+import { BaseNode, ParseOptions, MarkdownIt } from 'stream-markdown-parser';
+export * from 'stream-markdown-parser';
+export { KATEX_COMMANDS, MathOptions, normalizeStandaloneBackslashT, setDefaultMathOptions } from 'stream-markdown-parser';
+
+type LanguageIconResolver = (lang: string) => string | undefined | null;
+declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
+declare function normalizeLanguageIdentifier(lang?: string | null): string;
+declare function resolveMonacoLanguageId(lang?: string | null): string;
+declare function getLanguageIcon(lang: string): string;
+declare const languageMap: Record<string, string>;
+
+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$n = {
+    node: AdmonitionNode;
+    indexKey: number | string;
+    isDark?: boolean;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$x: vue.DefineComponent<__VLS_TypePropsToOption$u<__VLS_Props$n>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$u<__VLS_Props$n>>>, {}>;
+
+type __VLS_NonUndefinedable$u<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$u<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$u<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$a {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+interface BlockquoteNode {
+    type: 'blockquote';
+    children: NodeChild$a[];
+    raw: string;
+    cite?: string;
+}
+type __VLS_Props$m = {
+    node: BlockquoteNode;
+    indexKey: string | number;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$w: vue.DefineComponent<__VLS_TypePropsToOption$t<__VLS_Props$m>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$t<__VLS_Props$m>>>, {}>;
+
+type __VLS_NonUndefinedable$t<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$t<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$t<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+type __VLS_Props$l = {
+    node: {
+        type: 'checkbox';
+        checked: boolean;
+        raw: string;
+    };
+};
+declare const _default$v: vue.DefineComponent<__VLS_TypePropsToOption$s<__VLS_Props$l>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$s<__VLS_Props$l>>>, {}>;
+
+type __VLS_NonUndefinedable$s<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$s<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$s<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare function __VLS_template$5(): {
+    attrs: Partial<{}>;
+    slots: {
+        'header-left'?(_: {}): any;
+        'header-right'?(_: {}): any;
+        loading?(_: {
+            loading: boolean;
+            stream: boolean;
+        }): any;
+    };
+    refs: {
+        container: HTMLDivElement;
+        codeEditor: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult$5 = ReturnType<typeof __VLS_template$5>;
+declare const __VLS_component$5: vue.DefineComponent<{
+    node: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stream: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    darkTheme: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: any;
+    };
+    lightTheme: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: any;
+    };
+    isShowPreview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    monacoOptions: {
+        type: ObjectConstructor;
+        default: any;
+    };
+    enableFontSizeControl: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    maxWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    themes: {
+        type: ArrayConstructor;
+        default: any;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCopyButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showExpandButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showPreviewButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showFontSizeButtons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    customId: {
+        type: StringConstructor;
+        default: any;
+    };
+}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    previewCode: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<{
+    node: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stream: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    darkTheme: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: any;
+    };
+    lightTheme: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: any;
+    };
+    isShowPreview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    monacoOptions: {
+        type: ObjectConstructor;
+        default: any;
+    };
+    enableFontSizeControl: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    maxWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    themes: {
+        type: ArrayConstructor;
+        default: any;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCopyButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showExpandButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showPreviewButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showFontSizeButtons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    customId: {
+        type: StringConstructor;
+        default: any;
+    };
+}>>, {
+    customId: string;
+    themes: unknown[];
+    isDark: boolean;
+    maxWidth: string | number;
+    minWidth: string | number;
+    loading: boolean;
+    stream: boolean;
+    darkTheme: string | Record<string, any>;
+    lightTheme: string | Record<string, any>;
+    isShowPreview: boolean;
+    monacoOptions: Record<string, any>;
+    enableFontSizeControl: boolean;
+    showHeader: boolean;
+    showCopyButton: boolean;
+    showExpandButton: boolean;
+    showPreviewButton: boolean;
+    showFontSizeButtons: boolean;
+}>;
+declare const _default$u: __VLS_WithTemplateSlots$5<typeof __VLS_component$5, __VLS_TemplateResult$5["slots"]>;
+
+type __VLS_WithTemplateSlots$5<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};
+
+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$k = {
+    node: DefinitionListNode;
+    indexKey: string | number;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$t: vue.DefineComponent<__VLS_TypePropsToOption$r<__VLS_Props$k>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$r<__VLS_Props$k>>>, {}>;
+
+type __VLS_NonUndefinedable$r<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$r<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$r<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+type __VLS_Props$j = {
+    node: {
+        type: 'emoji';
+        name: string;
+        markup: string;
+        raw: string;
+    };
+};
+declare const _default$s: vue.DefineComponent<__VLS_TypePropsToOption$q<__VLS_Props$j>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$q<__VLS_Props$j>>>, {}>;
+
+type __VLS_NonUndefinedable$q<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$q<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$q<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+type __VLS_Props$i = {
+    node: {
+        type: 'footnote_anchor';
+        id: string;
+        raw?: string;
+    };
+};
+declare const _default$r: vue.DefineComponent<__VLS_TypePropsToOption$p<__VLS_Props$i>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$p<__VLS_Props$i>>>, {}>;
+
+type __VLS_NonUndefinedable$p<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$p<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$p<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface FootnoteNode {
+    type: 'footnote';
+    id: string;
+    children: {
+        type: string;
+        raw: string;
+    }[];
+    raw: string;
+}
+type __VLS_Props$h = {
+    node: FootnoteNode;
+    indexKey: string | number;
+    typewriter?: boolean;
+    customId?: string;
+};
+declare const _default$q: vue.DefineComponent<__VLS_TypePropsToOption$o<__VLS_Props$h>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$o<__VLS_Props$h>>>, {}>;
+
+type __VLS_NonUndefinedable$o<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$o<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$o<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface FootnoteReferenceNode {
+    type: 'footnote_reference';
+    id: string;
+    raw: string;
+}
+type __VLS_Props$g = {
+    node: FootnoteReferenceNode;
+};
+declare const _default$p: vue.DefineComponent<__VLS_TypePropsToOption$n<__VLS_Props$g>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$n<__VLS_Props$g>>>, {}>;
+
+type __VLS_NonUndefinedable$n<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$n<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$n<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface HardBreakNode {
+    type: 'hardbreak';
+    raw: string;
+}
+type __VLS_Props$f = {
+    node: HardBreakNode;
+};
+declare const _default$o: vue.DefineComponent<__VLS_TypePropsToOption$m<__VLS_Props$f>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$m<__VLS_Props$f>>>, {}>;
+
+type __VLS_NonUndefinedable$m<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$m<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$m<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$9 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$e = {
+    node: {
+        type: 'heading';
+        level: number;
+        text: string;
+        children: NodeChild$9[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$n: vue.DefineComponent<__VLS_TypePropsToOption$l<__VLS_Props$e>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$l<__VLS_Props$e>>>, {}>;
+
+type __VLS_NonUndefinedable$l<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$l<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$l<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$8 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$d = {
+    node: {
+        type: 'highlight';
+        children: NodeChild$8[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$m: vue.DefineComponent<__VLS_TypePropsToOption$k<__VLS_Props$d>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$k<__VLS_Props$d>>>, {}>;
+
+type __VLS_NonUndefinedable$k<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$k<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$k<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+type __VLS_Props$c = {
+    node: {
+        type: 'html_inline';
+        tag?: string;
+        content: string;
+        loading?: boolean;
+        autoClosed?: boolean;
+    };
+};
+declare const _default$l: vue.DefineComponent<__VLS_TypePropsToOption$j<__VLS_Props$c>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$j<__VLS_Props$c>>>, {}>;
+
+type __VLS_NonUndefinedable$j<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$j<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$j<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface ImageNodeProps {
+    node: {
+        type: 'image';
+        src: string;
+        alt: string;
+        title: string | null;
+        raw: string;
+        loading?: boolean;
+    };
+    fallbackSrc?: string;
+    showCaption?: boolean;
+    lazy?: boolean;
+    svgMinHeight?: string;
+    usePlaceholder?: boolean;
+}
+declare function __VLS_template$4(): {
+    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;
+            isSvg: 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;
+            isSvg: boolean;
+        }): any;
+    };
+    refs: {
+        figureRef: HTMLElement;
+    };
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult$4 = ReturnType<typeof __VLS_template$4>;
+declare const __VLS_component$4: vue.DefineComponent<__VLS_WithDefaults$3<__VLS_TypePropsToOption$i<ImageNodeProps>, {
+    fallbackSrc: string;
+    showCaption: boolean;
+    lazy: boolean;
+    svgMinHeight: string;
+    usePlaceholder: boolean;
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    load: (src: string) => void;
+    error: (src: string) => void;
+    click: (payload: [Event, string]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_WithDefaults$3<__VLS_TypePropsToOption$i<ImageNodeProps>, {
+    fallbackSrc: string;
+    showCaption: boolean;
+    lazy: boolean;
+    svgMinHeight: string;
+    usePlaceholder: boolean;
+}>>>, {
+    fallbackSrc: string;
+    showCaption: boolean;
+    lazy: boolean;
+    svgMinHeight: string;
+    usePlaceholder: boolean;
+}>;
+declare const _default$k: __VLS_WithTemplateSlots$4<typeof __VLS_component$4, __VLS_TemplateResult$4["slots"]>;
+
+type __VLS_WithDefaults$3<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal$3<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable$i<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$i<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$i<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots$4<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};
+type __VLS_PrettifyLocal$3<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+type __VLS_Props$b = {
+    node: {
+        type: 'inline_code';
+        code: string;
+        raw: string;
+    };
+};
+declare const _default$j: vue.DefineComponent<__VLS_TypePropsToOption$h<__VLS_Props$b>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$h<__VLS_Props$b>>>, {}>;
+
+type __VLS_NonUndefinedable$h<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$h<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$h<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$7 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$a = {
+    node: {
+        type: 'insert';
+        children: NodeChild$7[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$i: vue.DefineComponent<__VLS_TypePropsToOption$g<__VLS_Props$a>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$g<__VLS_Props$a>>>, {}>;
+
+type __VLS_NonUndefinedable$g<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$g<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$g<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface LinkNodeProps {
+    node: {
+        type: 'link';
+        href: string;
+        title: string | null;
+        text: 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;
+}
+declare const _default$h: vue.DefineComponent<__VLS_WithDefaults$2<__VLS_TypePropsToOption$f<LinkNodeProps>, {
+    showTooltip: boolean;
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_WithDefaults$2<__VLS_TypePropsToOption$f<LinkNodeProps>, {
+    showTooltip: boolean;
+}>>>, {
+    showTooltip: boolean;
+}>;
+
+type __VLS_WithDefaults$2<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal$2<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable$f<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$f<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$f<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal$2<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+interface NodeChild$6 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+interface ListItem$1 {
+    type: 'list_item';
+    children: NodeChild$6[];
+    raw: string;
+}
+type __VLS_Props$9 = {
+    item: ListItem$1;
+    indexKey?: number | string;
+    value?: number;
+    customId?: string;
+    /** Forwarded flag to enable/disable non-code node enter transition */
+    typewriter?: boolean;
+};
+declare const _default$g: vue.DefineComponent<__VLS_TypePropsToOption$e<__VLS_Props$9>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$e<__VLS_Props$9>>>, {}>;
+
+type __VLS_NonUndefinedable$e<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$e<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$e<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$5 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+interface ListItem {
+    type: 'list_item';
+    children: NodeChild$5[];
+    raw: string;
+}
+type __VLS_Props$8 = {
+    node: {
+        type: 'list';
+        ordered: boolean;
+        start?: number;
+        items: ListItem[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+    typewriter?: boolean;
+};
+declare const _default$f: vue.DefineComponent<__VLS_TypePropsToOption$d<__VLS_Props$8>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$d<__VLS_Props$8>>>, {}>;
+
+type __VLS_NonUndefinedable$d<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$d<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$d<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare function __VLS_template$3(): {
+    attrs: Partial<{}>;
+    slots: {
+        'header-left'?(_: {}): any;
+        'header-right'?(_: {}): any;
+        loading?(_: {
+            loading: boolean;
+            stream: boolean;
+        }): any;
+    };
+    refs: {
+        codeBlockContent: HTMLDivElement;
+        rendererTarget: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult$3 = ReturnType<typeof __VLS_template$3>;
+declare const __VLS_component$3: vue.DefineComponent<{
+    node: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stream: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    darkTheme: {
+        type: StringConstructor;
+        default: string;
+    };
+    lightTheme: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isShowPreview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableFontSizeControl: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    maxWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    themes: {
+        type: ArrayConstructor;
+        default: any;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCopyButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showExpandButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showPreviewButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showFontSizeButtons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    previewCode: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<{
+    node: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stream: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    darkTheme: {
+        type: StringConstructor;
+        default: string;
+    };
+    lightTheme: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isShowPreview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableFontSizeControl: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    maxWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    themes: {
+        type: ArrayConstructor;
+        default: any;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCopyButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showExpandButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showPreviewButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showFontSizeButtons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    themes: unknown[];
+    isDark: boolean;
+    maxWidth: string | number;
+    minWidth: string | number;
+    loading: boolean;
+    stream: boolean;
+    darkTheme: string;
+    lightTheme: string;
+    isShowPreview: boolean;
+    enableFontSizeControl: boolean;
+    showHeader: boolean;
+    showCopyButton: boolean;
+    showExpandButton: boolean;
+    showPreviewButton: boolean;
+    showFontSizeButtons: boolean;
+}>;
+declare const _default$e: __VLS_WithTemplateSlots$3<typeof __VLS_component$3, __VLS_TemplateResult$3["slots"]>;
+
+type __VLS_WithTemplateSlots$3<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};
+
+interface MathBlockNodeProps {
+    node: {
+        type: 'math_block';
+        content: string;
+        raw: string;
+        loading?: boolean;
+    };
+}
+declare const _default$d: vue.DefineComponent<__VLS_TypePropsToOption$c<MathBlockNodeProps>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$c<MathBlockNodeProps>>>, {}>;
+
+type __VLS_NonUndefinedable$c<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$c<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$c<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface MathInlineNodeProps {
+    node: {
+        type: 'math_inline';
+        content: string;
+        raw: string;
+        loading?: boolean;
+    };
+}
+declare function __VLS_template$2(): {
+    attrs: Partial<{}>;
+    slots: {
+        loading?(_: {
+            isLoading: true;
+        }): any;
+    };
+    refs: {
+        containerEl: HTMLSpanElement;
+        mathElement: HTMLSpanElement;
+    };
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult$2 = ReturnType<typeof __VLS_template$2>;
+declare const __VLS_component$2: vue.DefineComponent<__VLS_TypePropsToOption$b<MathInlineNodeProps>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$b<MathInlineNodeProps>>>, {}>;
+declare const _default$c: __VLS_WithTemplateSlots$2<typeof __VLS_component$2, __VLS_TemplateResult$2["slots"]>;
+
+type __VLS_NonUndefinedable$b<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$b<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$b<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots$2<T, S> = T & {
+    new (): {
+        $scopedSlots: 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;
+
+interface MermaidBlockNodeProps {
+    node: any;
+    maxHeight?: string | null;
+    loading?: boolean;
+    isDark?: boolean;
+    workerTimeoutMs?: number;
+    parseTimeoutMs?: number;
+    renderTimeoutMs?: number;
+    fullRenderTimeoutMs?: number;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showCollapseButton?: boolean;
+    showZoomControls?: boolean;
+    enableWheelZoom?: boolean;
+    isStrict?: boolean;
+}
+declare function __VLS_template$1(): {
+    attrs: Partial<{}>;
+    slots: {
+        'header-left'?(_: {}): any;
+        'header-center'?(_: {}): any;
+        'header-right'?(_: {}): any;
+    };
+    refs: {
+        modeContainerRef: HTMLDivElement;
+        mermaidContainer: HTMLDivElement;
+        mermaidContent: HTMLDivElement;
+        modalContent: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult$1 = ReturnType<typeof __VLS_template$1>;
+declare const __VLS_component$1: vue.DefineComponent<__VLS_WithDefaults$1<__VLS_TypePropsToOption$a<MermaidBlockNodeProps>, {
+    maxHeight: string;
+    loading: boolean;
+    workerTimeoutMs: number;
+    parseTimeoutMs: number;
+    renderTimeoutMs: number;
+    fullRenderTimeoutMs: number;
+    showHeader: boolean;
+    showModeToggle: boolean;
+    showCopyButton: boolean;
+    showExportButton: boolean;
+    showFullscreenButton: boolean;
+    showCollapseButton: boolean;
+    showZoomControls: boolean;
+    enableWheelZoom: boolean;
+    isStrict: boolean;
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    export: (...args: any[]) => void;
+    openModal: (...args: any[]) => void;
+    toggleMode: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_WithDefaults$1<__VLS_TypePropsToOption$a<MermaidBlockNodeProps>, {
+    maxHeight: string;
+    loading: boolean;
+    workerTimeoutMs: number;
+    parseTimeoutMs: number;
+    renderTimeoutMs: number;
+    fullRenderTimeoutMs: number;
+    showHeader: boolean;
+    showModeToggle: boolean;
+    showCopyButton: boolean;
+    showExportButton: boolean;
+    showFullscreenButton: boolean;
+    showCollapseButton: boolean;
+    showZoomControls: boolean;
+    enableWheelZoom: boolean;
+    isStrict: boolean;
+}>>>, {
+    maxHeight: string | null;
+    loading: boolean;
+    showHeader: boolean;
+    showCopyButton: boolean;
+    workerTimeoutMs: number;
+    parseTimeoutMs: number;
+    renderTimeoutMs: number;
+    fullRenderTimeoutMs: number;
+    showModeToggle: boolean;
+    showExportButton: boolean;
+    showFullscreenButton: boolean;
+    showCollapseButton: boolean;
+    showZoomControls: boolean;
+    enableWheelZoom: boolean;
+    isStrict: boolean;
+}>;
+declare const _default$b: __VLS_WithTemplateSlots$1<typeof __VLS_component$1, __VLS_TemplateResult$1["slots"]>;
+
+type __VLS_WithDefaults$1<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal$1<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable$a<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$a<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$a<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots$1<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};
+type __VLS_PrettifyLocal$1<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+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;
+
+interface NodeRendererProps {
+    content?: string;
+    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;
+    codeBlockDarkTheme?: any;
+    codeBlockLightTheme?: any;
+    codeBlockMonacoOptions?: Record<string, any>;
+    /** 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?: Record<string, any>;
+    themes?: string[];
+    isDark?: boolean;
+    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$a: vue.DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption$9<NodeRendererProps>, {
+    codeBlockStream: boolean;
+    typewriter: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+}>, {}, {}, {}, {}, 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, Readonly<vue.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption$9<NodeRendererProps>, {
+    codeBlockStream: boolean;
+    typewriter: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+}>>>, {
+    typewriter: boolean;
+    codeBlockStream: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+}>;
+
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable$9<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$9<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$9<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+interface NodeChild$4 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$7 = {
+    node: {
+        type: 'paragraph';
+        children: NodeChild$4[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$9: vue.DefineComponent<__VLS_TypePropsToOption$8<__VLS_Props$7>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$8<__VLS_Props$7>>>, {}>;
+
+type __VLS_NonUndefinedable$8<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$8<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$8<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface PreCodeNodeProps {
+    node: any;
+}
+declare const _default$8: vue.DefineComponent<__VLS_TypePropsToOption$7<PreCodeNodeProps>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$7<PreCodeNodeProps>>>, {}>;
+
+type __VLS_NonUndefinedable$7<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$7<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$7<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+type __VLS_Props$6 = {
+    node: {
+        type: 'reference';
+        id: string;
+        raw: string;
+    };
+    messageId?: string;
+    threadId?: string;
+};
+declare const _default$7: vue.DefineComponent<__VLS_TypePropsToOption$6<__VLS_Props$6>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+    mouseEnter: (...args: any[]) => void;
+    mouseLeave: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$6<__VLS_Props$6>>>, {}>;
+
+type __VLS_NonUndefinedable$6<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$6<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$6<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$3 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$5 = {
+    node: {
+        type: 'strikethrough';
+        children: NodeChild$3[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: string | number;
+};
+declare const _default$6: vue.DefineComponent<__VLS_TypePropsToOption$5<__VLS_Props$5>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$5<__VLS_Props$5>>>, {}>;
+
+type __VLS_NonUndefinedable$5<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$5<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$5<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$2 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$4 = {
+    node: {
+        type: 'strong';
+        children: NodeChild$2[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$5: vue.DefineComponent<__VLS_TypePropsToOption$4<__VLS_Props$4>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$4<__VLS_Props$4>>>, {}>;
+
+type __VLS_NonUndefinedable$4<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$4<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$4<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild$1 {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$3 = {
+    node: {
+        type: 'subscript';
+        children: NodeChild$1[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$4: vue.DefineComponent<__VLS_TypePropsToOption$3<__VLS_Props$3>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$3<__VLS_Props$3>>>, {}>;
+
+type __VLS_NonUndefinedable$3<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$3<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$3<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+interface NodeChild {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props$2 = {
+    node: {
+        type: 'superscript';
+        children: NodeChild[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default$3: vue.DefineComponent<__VLS_TypePropsToOption$2<__VLS_Props$2>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$2<__VLS_Props$2>>>, {}>;
+
+type __VLS_NonUndefinedable$2<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$2<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$2<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+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$1 = {
+    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_TypePropsToOption$1<__VLS_Props$1>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption$1<__VLS_Props$1>>>, {}>;
+declare const _default$2: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+type __VLS_NonUndefinedable$1<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption$1<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable$1<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};
+
+type __VLS_Props = {
+    node: {
+        type: 'text';
+        content: string;
+        raw: string;
+        center?: boolean;
+    };
+};
+declare const _default$1: vue.DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+}, string, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: vue.PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: vue.PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare const _default: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, Readonly<vue.ExtractPropTypes<{}>>, {}>;
+
+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;
+
+interface CustomComponents {
+    text: any;
+    paragraph: any;
+    heading: any;
+    code_block: any;
+    list: any;
+    blockquote: any;
+    table: any;
+    definition_list: any;
+    footnote: any;
+    footnote_reference: any;
+    admonition: any;
+    hardbreak: any;
+    link: any;
+    image: any;
+    thematic_break: any;
+    math_inline: any;
+    math_block: any;
+    strong: any;
+    emphasis: any;
+    strikethrough: any;
+    highlight: any;
+    insert: any;
+    subscript: any;
+    superscript: any;
+    emoji: any;
+    checkbox: any;
+    inline_code: any;
+    html_inline: any;
+    reference: any;
+    mermaid: any;
+    [key: string]: any;
+}
+
+declare function setCustomComponents(id: string, mapping: Partial<CustomComponents>): void;
+declare function setCustomComponents(mapping: Partial<CustomComponents>): 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>;
+/**
+ * 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;
+
+declare function getUseMonaco(): Promise<any>;
+
+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 VueRendererMarkdown: {
+    install(Vue: any, options?: {
+        getLanguageIcon?: LanguageIconResolver;
+        mathOptions?: any;
+    }): void;
+};
+
+export { _default$x as AdmonitionNode, BackpressureOptions, _default$w as BlockquoteNode, _default$v as CheckboxNode, _default$u as CodeBlockNode, _default$t as DefinitionListNode, _default$s as EmojiNode, _default$r as FootnoteAnchorNode, _default$q as FootnoteNode, _default$p as FootnoteReferenceNode, _default$o as HardBreakNode, _default$n as HeadingNode, _default$m as HighlightNode, _default$l as HtmlInlineNode, _default$k as ImageNode, _default$j as InlineCodeNode, _default$i as InsertNode, KaTeXCDNWorkerHandle, KaTeXCDNWorkerMode, KaTeXCDNWorkerOptions, KatexLoader, LanguageIconResolver, _default$h as LinkNode, _default$g as ListItemNode, _default$f as ListNode, MERMAID_DISABLED_CODE, MERMAID_WORKER_BUSY_CODE, _default$e as MarkdownCodeBlockNode, _default$a as MarkdownRender, _default$d as MathBlockNode, _default$c as MathInlineNode, _default$b as MermaidBlockNode, MermaidCDNWorkerHandle, MermaidCDNWorkerMode, MermaidCDNWorkerOptions, MermaidLoader, _default$9 as ParagraphNode, _default$8 as PreCodeNode, _default$7 as ReferenceNode, _default$6 as StrikethroughNode, _default$5 as StrongNode, _default$4 as SubscriptNode, _default$3 as SuperscriptNode, _default$2 as TableNode, _default$1 as TextNode, _default as ThematicBreakNode, VueRendererMarkdown, WORKER_BUSY_CODE, buildKaTeXCDNWorkerSource, buildMermaidCDNWorkerSource, canParseOffthread, clearGlobalCustomComponents, clearKaTeXWorker, clearMermaidWorker, createKaTeXWorkerFromCDN, createMermaidWorkerFromCDN, _default$a as default, disableKatex, disableMermaid, enableKatex, enableMermaid, findPrefixOffthread, getCustomNodeComponents, getKaTeXBackpressureDefaults, getKaTeXWorkerLoad, getLanguageIcon, getMermaidWorkerLoad, getUseMonaco, isKaTeXWorkerBusy, isKatexEnabled, isMermaidEnabled, languageMap, normalizeLanguageIdentifier, removeCustomComponents, renderKaTeXInWorker, renderKaTeXWithBackpressure, resolveMonacoLanguageId, setCustomComponents, setDefaultI18nMap, setKaTeXBackpressureDefaults, setKaTeXCache, setKaTeXWorker, setKaTeXWorkerDebug, setKaTeXWorkerMaxConcurrency, setKatexLoader, setLanguageIconResolver, setMermaidLoader, setMermaidWorker, setMermaidWorkerClientDebug, setMermaidWorkerMaxConcurrency, terminateWorker, waitForKaTeXWorkerSlot };