markstream-vue2 0.0.26 → 0.0.28

package/dist/types/components/MarkdownCodeBlockNode/index.d.ts

@@ -0,0 +1,2 @@
+import { default as MarkdownCodeBlockNode } from './MarkdownCodeBlockNode.vue';
+export default MarkdownCodeBlockNode;

package/dist/types/components/MarkdownRenderCompat.vue.d.ts

@@ -0,0 +1,94 @@
+import { BaseNode, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+import { NodeRendererProps } from './NodeRenderer/NodeRenderer.vue';
+declare const _default: import('vue-demi').DefineComponent<{
+    content: StringConstructor;
+    nodes: () => BaseNode[] | undefined;
+    final: BooleanConstructor;
+    parseOptions: () => ParseOptions | undefined;
+    customMarkdownIt: () => ((md: MarkdownIt) => MarkdownIt) | undefined;
+    debugPerformance: BooleanConstructor;
+    customHtmlTags: () => readonly string[] | undefined;
+    viewportPriority: BooleanConstructor;
+    codeBlockStream: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    codeBlockDarkTheme: any;
+    codeBlockLightTheme: any;
+    codeBlockMonacoOptions: () => Record<string, any> | undefined;
+    renderCodeBlocksAsPre: BooleanConstructor;
+    codeBlockMinWidth: (NumberConstructor | StringConstructor)[];
+    codeBlockMaxWidth: (NumberConstructor | StringConstructor)[];
+    codeBlockProps: () => Record<string, any> | undefined;
+    showTooltips: BooleanConstructor;
+    themes: () => string[] | undefined;
+    isDark: BooleanConstructor;
+    customId: (NumberConstructor | StringConstructor)[];
+    indexKey: (NumberConstructor | StringConstructor)[];
+    typewriter: BooleanConstructor;
+    batchRendering: BooleanConstructor;
+    initialRenderBatchSize: NumberConstructor;
+    renderBatchSize: NumberConstructor;
+    renderBatchDelay: NumberConstructor;
+    renderBatchBudgetMs: NumberConstructor;
+    renderBatchIdleTimeoutMs: NumberConstructor;
+    deferNodesUntilVisible: BooleanConstructor;
+    maxLiveNodes: NumberConstructor;
+    liveNodeBuffer: NumberConstructor;
+}, {}, {
+    instanceMsgId: string;
+}, {
+    legacyVue26(): boolean;
+    mergedParseOptions(): ParseOptions | undefined;
+    parsedLegacyNodes(): BaseNode[];
+    forwardedProps(): NodeRendererProps;
+}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('vue-demi').ExtractPropTypes<{
+    content: StringConstructor;
+    nodes: () => BaseNode[] | undefined;
+    final: BooleanConstructor;
+    parseOptions: () => ParseOptions | undefined;
+    customMarkdownIt: () => ((md: MarkdownIt) => MarkdownIt) | undefined;
+    debugPerformance: BooleanConstructor;
+    customHtmlTags: () => readonly string[] | undefined;
+    viewportPriority: BooleanConstructor;
+    codeBlockStream: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    codeBlockDarkTheme: any;
+    codeBlockLightTheme: any;
+    codeBlockMonacoOptions: () => Record<string, any> | undefined;
+    renderCodeBlocksAsPre: BooleanConstructor;
+    codeBlockMinWidth: (NumberConstructor | StringConstructor)[];
+    codeBlockMaxWidth: (NumberConstructor | StringConstructor)[];
+    codeBlockProps: () => Record<string, any> | undefined;
+    showTooltips: BooleanConstructor;
+    themes: () => string[] | undefined;
+    isDark: BooleanConstructor;
+    customId: (NumberConstructor | StringConstructor)[];
+    indexKey: (NumberConstructor | StringConstructor)[];
+    typewriter: BooleanConstructor;
+    batchRendering: BooleanConstructor;
+    initialRenderBatchSize: NumberConstructor;
+    renderBatchSize: NumberConstructor;
+    renderBatchDelay: NumberConstructor;
+    renderBatchBudgetMs: NumberConstructor;
+    renderBatchIdleTimeoutMs: NumberConstructor;
+    deferNodesUntilVisible: BooleanConstructor;
+    maxLiveNodes: NumberConstructor;
+    liveNodeBuffer: NumberConstructor;
+}>>, {
+    codeBlockStream: boolean;
+    showTooltips: boolean;
+    typewriter: boolean;
+    codeBlockDarkTheme: any;
+    codeBlockLightTheme: any;
+    renderCodeBlocksAsPre: boolean;
+    isDark: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    deferNodesUntilVisible: boolean;
+    final: boolean;
+    viewportPriority: boolean;
+}>;
+export default _default;

package/dist/types/components/MathBlockNode/MathBlockNode.vue.d.ts

@@ -0,0 +1,20 @@
+interface MathBlockNodeProps {
+    node: {
+        type: 'math_block';
+        content: string;
+        raw: string;
+        loading?: boolean;
+    };
+    indexKey?: number | string;
+}
+declare const _default: import('vue-demi').DefineComponent<__VLS_TypePropsToOption<MathBlockNodeProps>, {}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('vue-demi').ExtractPropTypes<__VLS_TypePropsToOption<MathBlockNodeProps>>>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/components/MathBlockNode/index.d.ts

@@ -0,0 +1,2 @@
+import { default as MathBlockNode } from './MathBlockNode.vue';
+export default MathBlockNode;

package/dist/types/components/MathInlineNode/MathInlineNode.vue.d.ts

@@ -0,0 +1,40 @@
+interface MathInlineNodeProps {
+    node: {
+        type: 'math_inline';
+        content: string;
+        raw: string;
+        loading?: boolean;
+        markup?: string;
+    };
+    indexKey?: number | string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        loading?(_: {
+            isLoading: true;
+        }): any;
+    };
+    refs: {
+        containerEl: HTMLSpanElement;
+    };
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue-demi').DefineComponent<__VLS_TypePropsToOption<MathInlineNodeProps>, {}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('vue-demi').ExtractPropTypes<__VLS_TypePropsToOption<MathInlineNodeProps>>>, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/dist/types/components/MathInlineNode/index.d.ts

@@ -0,0 +1,2 @@
+import { default as MathInlineNode } from './MathInlineNode.vue';
+export default MathInlineNode;

package/dist/types/components/MathInlineNode/katex.d.ts

@@ -0,0 +1,6 @@
+export type KatexLoader = () => Promise<any> | any;
+export declare function setKatexLoader(loader: KatexLoader | null): void;
+export declare function enableKatex(loader?: KatexLoader): void;
+export declare function disableKatex(): void;
+export declare function isKatexEnabled(): boolean;
+export declare function getKatex(): Promise<any>;

package/dist/types/components/MermaidBlockNode/MermaidBlockNode.vue.d.ts

@@ -0,0 +1,134 @@
+interface MermaidBlockNodeProps {
+    node: any;
+    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;
+    onRenderError?: (error: unknown, code: string, container: HTMLElement) => boolean | void;
+}
+declare function __VLS_template(): {
+    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 = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue-demi').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MermaidBlockNodeProps>, {
+    maxHeight: string;
+    loading: 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;
+}>, {}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    export: (...args: any[]) => void;
+    openModal: (...args: any[]) => void;
+    toggleMode: (...args: any[]) => void;
+}, string, Readonly<import('vue-demi').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MermaidBlockNodeProps>, {
+    maxHeight: string;
+    loading: 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;
+}>>>, {
+    loading: boolean;
+    maxHeight: string | null;
+    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;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+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<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/MermaidBlockNode/index.d.ts

@@ -0,0 +1,2 @@
+import { default as MermaidBlockNode } from './MermaidBlockNode.vue';
+export default MermaidBlockNode;

package/dist/types/components/MermaidBlockNode/mermaid.d.ts

@@ -0,0 +1,6 @@
+export type MermaidLoader = () => Promise<any> | any;
+export declare function setMermaidLoader(loader: MermaidLoader | null): void;
+export declare function enableMermaid(loader?: MermaidLoader): void;
+export declare function disableMermaid(): void;
+export declare function isMermaidEnabled(): boolean;
+export declare function getMermaid(): Promise<any>;

package/dist/types/components/NestedRenderer/NestedRenderer.vue.d.ts

@@ -0,0 +1,30 @@
+import { BaseNode, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+declare const _default: import('vue-demi').DefineComponent<{
+    node: () => (BaseNode & Record<string, any>) | undefined;
+    nodes: () => BaseNode[] | undefined;
+    content: StringConstructor;
+    loading: BooleanConstructor;
+    final: BooleanConstructor;
+    cacheKey: StringConstructor;
+    parseOptions: () => ParseOptions | undefined;
+    customHtmlTags: () => readonly string[] | undefined;
+    customMarkdownIt: () => ((md: MarkdownIt) => MarkdownIt) | undefined;
+}, {
+    forwardedListeners: import('vue-demi').ComputedRef<Record<string, ((...args: unknown[]) => unknown) | ((...args: unknown[]) => unknown)[]>>;
+    resolvedFinal: import('vue-demi').ComputedRef<boolean>;
+    resolvedNodes: import('vue-demi').ComputedRef<BaseNode[]>;
+}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('vue-demi').ExtractPropTypes<{
+    node: () => (BaseNode & Record<string, any>) | undefined;
+    nodes: () => BaseNode[] | undefined;
+    content: StringConstructor;
+    loading: BooleanConstructor;
+    final: BooleanConstructor;
+    cacheKey: StringConstructor;
+    parseOptions: () => ParseOptions | undefined;
+    customHtmlTags: () => readonly string[] | undefined;
+    customMarkdownIt: () => ((md: MarkdownIt) => MarkdownIt) | undefined;
+}>>, {
+    final: boolean;
+    loading: boolean;
+}>;
+export default _default;

package/dist/types/components/NestedRenderer/index.d.ts

@@ -0,0 +1,2 @@
+import { default as NestedRenderer } from './NestedRenderer.vue';
+export default NestedRenderer;

package/dist/types/components/NodeRenderer/FallbackComponent.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    node: {
+        raw: string;
+    };
+};
+declare const _default: import('../../../vue-demi').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import('../../../vue-demi').ComponentOptionsMixin, import('../../../vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('../../../vue-demi').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/components/NodeRenderer/LegacyNodesRenderer.vue.d.ts

@@ -0,0 +1,53 @@
+import { BaseNode } from 'stream-markdown-parser';
+type __VLS_Props = {
+    nodes?: BaseNode[];
+    customId?: string;
+    indexKey?: number | string;
+    typewriter?: boolean;
+    showTooltips?: boolean;
+    codeBlockStream?: boolean;
+    codeBlockDarkTheme?: any;
+    codeBlockLightTheme?: any;
+    codeBlockMonacoOptions?: Record<string, any>;
+    codeBlockMinWidth?: string | number;
+    codeBlockMaxWidth?: string | number;
+    codeBlockProps?: Record<string, any>;
+    renderCodeBlocksAsPre?: boolean;
+    themes?: string[];
+    isDark?: boolean;
+    customHtmlTags?: readonly string[];
+};
+declare const _default: import('vue-demi').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    codeBlockStream: boolean;
+    showTooltips: boolean;
+    typewriter: boolean;
+}>, {}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    handleArtifactClick: (...args: any[]) => void;
+}, string, Readonly<import('vue-demi').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    codeBlockStream: boolean;
+    showTooltips: boolean;
+    typewriter: boolean;
+}>>>, {
+    codeBlockStream: boolean;
+    showTooltips: boolean;
+    typewriter: boolean;
+}>;
+export default _default;
+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<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/NodeRenderer/NodeRenderer.vue.d.ts

@@ -0,0 +1,139 @@
+import { BaseNode, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+import { D2BlockNodeProps, InfographicBlockNodeProps, MermaidBlockNodeProps } from '../../types/component-props';
+export 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>;
+    /** 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;
+    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: import('vue-demi').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<NodeRendererProps>, {
+    codeBlockStream: boolean;
+    showTooltips: boolean;
+    typewriter: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+}>, {}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {
+    copy: (...args: any[]) => void;
+    handleArtifactClick: (...args: any[]) => void;
+    click: (...args: any[]) => void;
+    mouseover: (...args: any[]) => void;
+    mouseout: (...args: any[]) => void;
+}, string, Readonly<import('vue-demi').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NodeRendererProps>, {
+    codeBlockStream: boolean;
+    showTooltips: boolean;
+    typewriter: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+}>>>, {
+    codeBlockStream: boolean;
+    showTooltips: boolean;
+    typewriter: boolean;
+    batchRendering: boolean;
+    debugPerformance: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+}>;
+export default _default;
+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<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/NodeRenderer/asyncComponent.d.ts

@@ -0,0 +1,2 @@
+export declare function MathInlineNodeAsync(): Promise<any>;
+export declare function MathBlockNodeAsync(): Promise<any>;

package/dist/types/components/NodeRenderer/index.d.ts

@@ -0,0 +1,2 @@
+import { default as NodeRenderer } from './NodeRenderer.vue';
+export default NodeRenderer;

package/dist/types/components/NodeRenderer/preloadMonaco.d.ts

@@ -0,0 +1 @@
+export declare function preload(m: any): Promise<any>;

package/dist/types/components/ParagraphNode/ParagraphNode.vue.d.ts

@@ -0,0 +1,25 @@
+interface NodeChild {
+    type: string;
+    raw: string;
+    [key: string]: unknown;
+}
+type __VLS_Props = {
+    node: {
+        type: 'paragraph';
+        children: NodeChild[];
+        raw: string;
+    };
+    customId?: string;
+    indexKey?: number | string;
+};
+declare const _default: import('../../../vue-demi').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import('../../../vue-demi').ComponentOptionsMixin, import('../../../vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('../../../vue-demi').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/components/ParagraphNode/index.d.ts

@@ -0,0 +1,2 @@
+import { default as ParagraphNode } from './ParagraphNode.vue';
+export default ParagraphNode;

package/dist/types/components/Portal/Portal.vue.d.ts

@@ -0,0 +1,31 @@
+type __VLS_Props = {
+    to?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        rootRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue-demi').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('vue-demi').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/dist/types/components/Portal/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Portal } from './Portal.vue';
+export default Portal;

package/dist/types/components/PreCodeNode/PreCodeNode.vue.d.ts

@@ -0,0 +1,14 @@
+interface PreCodeNodeProps {
+    node: any;
+}
+declare const _default: import('vue-demi').DefineComponent<__VLS_TypePropsToOption<PreCodeNodeProps>, {}, {}, {}, {}, import('vue-demi').ComponentOptionsMixin, import('vue-demi').ComponentOptionsMixin, {}, string, Readonly<import('vue-demi').ExtractPropTypes<__VLS_TypePropsToOption<PreCodeNodeProps>>>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('../../../vue-demi').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('../../../vue-demi').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/components/PreCodeNode/index.d.ts

@@ -0,0 +1,2 @@
+import { default as PreCodeNode } from './PreCodeNode.vue';
+export default PreCodeNode;