@hejiayue/x-markdown-test 0.0.1-beta.107

package/dist/style.css

@@ -0,0 +1 @@
+.x-md-syntax-code-block[data-v-7cbaa1d1]{width:100%}.x-md-syntax-code-block pre[data-v-7cbaa1d1]{margin:0;padding:16px;overflow:auto;background:transparent!important}.x-md-code-content[data-v-7cbaa1d1]{display:flex;flex-direction:column}.x-md-code-line[data-v-7cbaa1d1]{width:100%;font-size:14px;line-height:1.5;display:flex}.x-md-code-block[data-v-8b0fb0b9]{border-radius:8px;overflow:hidden;font-size:0;background:#00000008}.x-md-code-block.x-md-code-block--dark[data-v-8b0fb0b9]{background:#ffffff21}.x-md-code-header-wrapper--sticky[data-v-8b0fb0b9]{background:#fff;position:sticky;top:0}.x-md-code-block.x-md-code-block--dark .x-md-code-header-wrapper--sticky[data-v-8b0fb0b9]{background:#1a1a1a}.x-md-code-header[data-v-8b0fb0b9]{display:flex;justify-content:space-between;align-items:center;padding:8px 16px;background:#0000000d;color:#333}.x-md-code-block .x-md-code-header-wrapper--sticky .x-md-code-header[data-v-8b0fb0b9]{background:#ebebeb;border-radius:8px 8px 0 0}.x-md-code-block[data-v-8b0fb0b9]:has(.x-md-code-header-wrapper--sticky){overflow:visible}.x-md-code-block.x-md-code-block--dark .x-md-code-header[data-v-8b0fb0b9]{background:#00000040;color:#fff}.x-md-code-block.x-md-code-block--dark .x-md-code-header-wrapper--sticky .x-md-code-header[data-v-8b0fb0b9]{background:#2c2c2c}.x-md-code-block .x-md-code-header-wrapper--collapsed .x-md-code-header[data-v-8b0fb0b9]{border-radius:8px}.x-md-code-header__left[data-v-8b0fb0b9],.x-md-code-header__right[data-v-8b0fb0b9]{display:flex;align-items:center;gap:8px}.x-md-code-lang[data-v-8b0fb0b9]{font-size:12px;font-weight:500;opacity:.6;text-transform:lowercase}.x-md-copy-btn[data-v-8b0fb0b9]{display:flex;align-items:center;justify-content:center;width:28px;height:28px;padding:0;border:none;border-radius:4px;background:transparent;color:inherit;cursor:pointer;opacity:.7;transition:all .2s ease}.x-md-copy-btn[data-v-8b0fb0b9]:hover{opacity:1;background:#00000014}.x-md-code-block.x-md-code-block--dark .x-md-copy-btn[data-v-8b0fb0b9]:hover{background:#ffffff1a}.x-md-copy-btn.x-md-copy-btn--copied[data-v-8b0fb0b9]{opacity:1;color:#22c55e}.x-md-copy-icon[data-v-8b0fb0b9]{flex-shrink:0}.x-md-action-btn[data-v-8b0fb0b9]{display:flex;align-items:center;justify-content:center;width:28px;height:28px;padding:0;border:none;border-radius:4px;background:transparent;color:inherit;cursor:pointer;opacity:.7;transition:all .2s ease}.x-md-action-btn[data-v-8b0fb0b9]:hover{opacity:1;background:#00000014}.x-md-code-block.x-md-code-block--dark .x-md-action-btn[data-v-8b0fb0b9]:hover{background:#ffffff1a}.x-md-action-btn.x-md-action-btn--disabled[data-v-8b0fb0b9]{opacity:.3;cursor:not-allowed;pointer-events:none}.x-md-action-icon[data-v-8b0fb0b9]{display:flex;align-items:center;justify-content:center}.x-md-action-icon[data-v-8b0fb0b9] svg{width:16px;height:16px;flex-shrink:0}.x-md-collapse-btn[data-v-8b0fb0b9]{display:flex;align-items:center;justify-content:center;width:20px;height:20px;padding:0;border:none;border-radius:4px;background:transparent;color:inherit;cursor:pointer;opacity:.5;transition:all .2s ease}.x-md-collapse-btn[data-v-8b0fb0b9]:hover{opacity:1;background:#00000014}.x-md-code-block.x-md-code-block--dark .x-md-collapse-btn[data-v-8b0fb0b9]:hover{background:#ffffff1a}.x-md-collapse-icon[data-v-8b0fb0b9]{transition:transform .2s ease}.x-md-collapse-btn--collapsed .x-md-collapse-icon[data-v-8b0fb0b9]{transform:rotate(-90deg)}.x-md-code-body[data-v-8b0fb0b9]{overflow:hidden;transition:max-height .3s ease,opacity .2s ease}.x-md-code-body--collapsed[data-v-8b0fb0b9]{max-height:0!important;opacity:0}.x-md-inline-code[data-v-97166d5b]{display:inline-block;border-radius:8px;overflow:hidden;font-size:14px;background:#00000008;vertical-align:sub}.x-md-inline-code.x-md-inline-code--dark[data-v-97166d5b]{background:#ffffff21}.x-md-inline-code code[data-v-97166d5b]{background:transparent!important}@keyframes fadeIn{0%{opacity:0}to{opacity:1}}.x-md-animated-word{animation:fadeIn .3s ease-in-out}.x-md-renderer pre{margin:16px 0;padding:0;overflow:auto;background:transparent!important}.x-md-renderer pre:has(.x-md-code-header-wrapper--sticky){overflow:unset}.katex-error{color:var(--el-text-color-secondary)!important}.katex-html{overflow:auto hidden;padding:3px}.syntax-mermaid{display:flex;align-items:center;justify-content:center;min-height:200px;overflow:hidden;cursor:grab;position:relative}.syntax-mermaid__render-container{position:absolute;max-height:0;opacity:0;overflow:hidden;pointer-events:none}.syntax-mermaid:active{cursor:grabbing}.syntax-mermaid__content{width:100%;height:100%;display:flex;align-items:center;justify-content:center}.syntax-mermaid__content svg{transform-origin:center center;max-width:100%;max-height:100%}.syntax-mermaid:fullscreen{max-height:100vh}.syntax-mermaid:fullscreen .syntax-mermaid__content{justify-content:center}.syntax-mermaid__loading{display:flex;align-items:center;justify-content:center;width:100%;height:100%;min-height:200px}.syntax-mermaid__loading-text{color:#666;font-size:14px}.syntax-mermaid--dark .syntax-mermaid__loading-text{color:#999}.markdown-mermaid{border-radius:8px;overflow:hidden;font-size:0;background:#00000008}.markdown-mermaid.markdown-mermaid--dark{background:#ffffff21}.markdown-mermaid .toolbar-container{position:relative;z-index:10;flex-shrink:0;background:#0000000d;color:#333}.markdown-mermaid.markdown-mermaid--dark .toolbar-container{background:#00000040;color:#fff}.markdown-mermaid .mermaid-toolbar{display:flex;justify-content:space-between;align-items:center;padding:8px 16px;background:transparent;color:inherit}.markdown-mermaid .mermaid-toolbar .toolbar-left{display:flex;align-items:center}.markdown-mermaid .mermaid-toolbar .segmented-control{display:flex;align-items:center;position:relative;background:#0000000f;border-radius:6px;padding:3px;gap:2px}.markdown-mermaid.markdown-mermaid--dark .mermaid-toolbar .segmented-control{background:#ffffff14}.markdown-mermaid .mermaid-toolbar .segmented-slider{position:absolute;top:3px;left:3px;width:calc(50% - 4px);height:calc(100% - 6px);background:#fff;border-radius:4px;box-shadow:0 1px 3px #0000001a;transition:transform .25s cubic-bezier(.4,0,.2,1);z-index:0}.markdown-mermaid.markdown-mermaid--dark .mermaid-toolbar .segmented-slider{background:#ffffff26;box-shadow:0 1px 3px #0003}.markdown-mermaid .mermaid-toolbar .segmented-slider.slide-right{transform:translate(calc(100% + 2px))}.markdown-mermaid .mermaid-toolbar .segment-item{display:flex;align-items:center;justify-content:center;gap:4px;font-size:12px;border:none;color:inherit;min-width:60px;text-align:center;box-sizing:border-box;font-weight:500;cursor:pointer;border-radius:4px;padding:5px 12px;transition:all .2s ease;background:transparent;opacity:.6;user-select:none;position:relative;z-index:1}.markdown-mermaid .mermaid-toolbar .segment-item.active{opacity:1}.markdown-mermaid.markdown-mermaid--dark .mermaid-toolbar .segment-item.active{color:#fff}.markdown-mermaid .mermaid-toolbar .segment-item:hover{opacity:1}.markdown-mermaid .mermaid-toolbar .segment-item svg{flex-shrink:0}.markdown-mermaid .mermaid-toolbar .toolbar-right{display:flex;align-items:center;gap:16px}.markdown-mermaid .mermaid-toolbar .toolbar-action-btn{display:flex;align-items:center;justify-content:center;width:28px;height:28px;padding:0;border:none;border-radius:4px;background:transparent;color:inherit;cursor:pointer;transition:all .2s ease;opacity:.7}.markdown-mermaid .mermaid-toolbar .toolbar-action-btn:hover{opacity:1;background:#00000014}.markdown-mermaid .mermaid-toolbar .toolbar-action-btn.copy-success{opacity:1;color:#22c55e}.markdown-mermaid.markdown-mermaid--dark .mermaid-toolbar .toolbar-action-btn:hover{background:#ffffff1a}.markdown-mermaid .mermaid-toolbar .toolbar-action-btn.toolbar-action-btn--disabled{opacity:.3;cursor:not-allowed;pointer-events:none}.markdown-mermaid .mermaid-toolbar .mermaid-action-icon{display:flex;align-items:center;justify-content:center}.markdown-mermaid .mermaid-toolbar .mermaid-action-icon :deep(svg){width:16px;height:16px;flex-shrink:0}.markdown-mermaid .mermaid-source-code{position:relative;z-index:1;flex:1;width:100%;overflow:auto;box-sizing:border-box}.toolbar-enter-active,.toolbar-leave-active{transition:opacity .3s ease}.toolbar-enter-from,.toolbar-leave-to{opacity:0}

package/dist/types/MarkdownRender/index.d.ts

@@ -0,0 +1,441 @@
+import type { PropType } from 'vue';
+import type { PluggableList } from 'unified';
+import type { CodeBlockAction } from '../components/CodeBlock/types';
+import type { MermaidAction } from '../components/Mermaid/types';
+import type { CustomAttrs, SanitizeOptions } from '../core/types';
+import './index.css';
+/**
+ * Markdown 渲染器组件 - 同步版本
+ * 直接渲染 Markdown 内容
+ */
+declare const MarkdownRenderer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        default: string;
+    };
+    allowHtml: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableLatex: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableAnimate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableBreaks: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableGfm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    shikiTheme: {
+        type: PropType<[string, string]>;
+        default: () => [string, string];
+    };
+    showCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stickyCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    codeMaxHeight: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    codeBlockActions: {
+        type: PropType<CodeBlockAction[]>;
+        default: undefined;
+    };
+    mermaidActions: {
+        type: PropType<MermaidAction[]>;
+        default: undefined;
+    };
+    mermaidConfig: {
+        type: PropType<Record<string, any>>;
+        default: undefined;
+    };
+    codeXRender: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    customAttrs: {
+        type: PropType<CustomAttrs>;
+        default: () => {};
+    };
+    remarkPlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    remarkPluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypeOptions: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    sanitize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sanitizeOptions: {
+        type: PropType<SanitizeOptions>;
+        default: () => {};
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        default: string;
+    };
+    allowHtml: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableLatex: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableAnimate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableBreaks: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableGfm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    shikiTheme: {
+        type: PropType<[string, string]>;
+        default: () => [string, string];
+    };
+    showCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stickyCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    codeMaxHeight: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    codeBlockActions: {
+        type: PropType<CodeBlockAction[]>;
+        default: undefined;
+    };
+    mermaidActions: {
+        type: PropType<MermaidAction[]>;
+        default: undefined;
+    };
+    mermaidConfig: {
+        type: PropType<Record<string, any>>;
+        default: undefined;
+    };
+    codeXRender: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    customAttrs: {
+        type: PropType<CustomAttrs>;
+        default: () => {};
+    };
+    remarkPlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    remarkPluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypeOptions: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    sanitize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sanitizeOptions: {
+        type: PropType<SanitizeOptions>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    sanitize: boolean;
+    markdown: string;
+    customAttrs: CustomAttrs;
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+    rehypeOptions: Record<string, any>;
+    sanitizeOptions: SanitizeOptions;
+    codeXRender: Record<string, any>;
+    isDark: boolean;
+    shikiTheme: [string, string];
+    enableAnimate: boolean;
+    showCodeBlockHeader: boolean;
+    stickyCodeBlockHeader: boolean;
+    codeMaxHeight: string;
+    codeBlockActions: CodeBlockAction[];
+    mermaidActions: MermaidAction[];
+    mermaidConfig: Record<string, any>;
+    allowHtml: boolean;
+    enableLatex: boolean;
+    enableBreaks: boolean;
+    enableGfm: boolean;
+    rehypePluginsAhead: PluggableList;
+    remarkPluginsAhead: PluggableList;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Markdown 渲染器组件 - 异步版本
+ * 异步渲染 Markdown 内容
+ */
+declare const MarkdownRendererAsync: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        default: string;
+    };
+    allowHtml: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableLatex: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableAnimate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableBreaks: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableGfm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    shikiTheme: {
+        type: PropType<[string, string]>;
+        default: () => [string, string];
+    };
+    showCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stickyCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    codeMaxHeight: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    codeBlockActions: {
+        type: PropType<CodeBlockAction[]>;
+        default: undefined;
+    };
+    mermaidActions: {
+        type: PropType<MermaidAction[]>;
+        default: undefined;
+    };
+    mermaidConfig: {
+        type: PropType<Record<string, any>>;
+        default: undefined;
+    };
+    codeXRender: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    customAttrs: {
+        type: PropType<CustomAttrs>;
+        default: () => {};
+    };
+    remarkPlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    remarkPluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypeOptions: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    sanitize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sanitizeOptions: {
+        type: PropType<SanitizeOptions>;
+        default: () => {};
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        default: string;
+    };
+    allowHtml: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableLatex: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableAnimate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableBreaks: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableGfm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    shikiTheme: {
+        type: PropType<[string, string]>;
+        default: () => [string, string];
+    };
+    showCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stickyCodeBlockHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    codeMaxHeight: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    codeBlockActions: {
+        type: PropType<CodeBlockAction[]>;
+        default: undefined;
+    };
+    mermaidActions: {
+        type: PropType<MermaidAction[]>;
+        default: undefined;
+    };
+    mermaidConfig: {
+        type: PropType<Record<string, any>>;
+        default: undefined;
+    };
+    codeXRender: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    customAttrs: {
+        type: PropType<CustomAttrs>;
+        default: () => {};
+    };
+    remarkPlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    remarkPluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePlugins: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypePluginsAhead: {
+        type: PropType<PluggableList>;
+        default: () => never[];
+    };
+    rehypeOptions: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    sanitize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sanitizeOptions: {
+        type: PropType<SanitizeOptions>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    sanitize: boolean;
+    markdown: string;
+    customAttrs: CustomAttrs;
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+    rehypeOptions: Record<string, any>;
+    sanitizeOptions: SanitizeOptions;
+    codeXRender: Record<string, any>;
+    isDark: boolean;
+    shikiTheme: [string, string];
+    enableAnimate: boolean;
+    showCodeBlockHeader: boolean;
+    stickyCodeBlockHeader: boolean;
+    codeMaxHeight: string;
+    codeBlockActions: CodeBlockAction[];
+    mermaidActions: MermaidAction[];
+    mermaidConfig: Record<string, any>;
+    allowHtml: boolean;
+    enableLatex: boolean;
+    enableBreaks: boolean;
+    enableGfm: boolean;
+    rehypePluginsAhead: PluggableList;
+    remarkPluginsAhead: PluggableList;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export { MarkdownRenderer, MarkdownRendererAsync };

package/dist/types/core/components.d.ts

@@ -0,0 +1,4 @@
+import type { CustomAttrs, SanitizeOptions, TVueMarkdown } from './types';
+export type { CustomAttrs, SanitizeOptions, TVueMarkdown };
+export declare const VueMarkdown: TVueMarkdown;
+export declare const VueMarkdownAsync: TVueMarkdown;

package/dist/types/core/hast-to-vnode.d.ts

@@ -0,0 +1,13 @@
+import type { Element, Root, RootContent } from 'hast';
+import type { MaybeRefOrGetter, Slots, VNode, VNodeArrayChildren } from 'vue';
+import type { AliasList, Context, CustomAttrs } from './types';
+export declare function render(hast: Root, attrs: Record<string, unknown>, slots?: Slots, customAttrs?: MaybeRefOrGetter<CustomAttrs>): VNode;
+export declare function renderChildren(nodeList: (RootContent | Root)[], ctx: Context, parent: Element | Root, slots: Slots, customAttrs: CustomAttrs, keyCounter: {
+    [key: string]: number;
+}): VNodeArrayChildren;
+export declare function getVNodeInfos(node: RootContent, parent: Element | Root, context: Context, keyCounter: Record<string, number>, customAttrs: CustomAttrs): {
+    attrs: Record<string, unknown>;
+    context: Context;
+    aliasList: AliasList;
+    vnodeProps: Record<string, any>;
+};

package/dist/types/core/index.d.ts

@@ -0,0 +1,6 @@
+export { VueMarkdown, VueMarkdownAsync } from './components';
+export { getVNodeInfos, render, renderChildren } from './hast-to-vnode';
+export type * from './types';
+export type { CodeLineProps } from '../components/CodeLine/types';
+export type { MarkdownContext } from '../MarkdownRender/types';
+export { createProcessor, useMarkdownProcessor } from './useProcessor';

package/dist/types/core/useProcessor.d.ts

@@ -0,0 +1,23 @@
+import type { Root } from 'hast';
+import type { Root as MdastRoot } from 'mdast';
+import type { Options as TRehypeOptions } from 'mdast-util-to-hast';
+import type { PluggableList, Processor } from 'unified';
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+import type { SanitizeOptions } from './types';
+export interface TUseMarkdownProcessorOptions {
+    remarkPlugins?: MaybeRefOrGetter<PluggableList>;
+    rehypePlugins?: MaybeRefOrGetter<PluggableList>;
+    rehypeOptions?: MaybeRefOrGetter<Omit<TRehypeOptions, 'file'>>;
+    sanitize?: MaybeRefOrGetter<boolean>;
+    sanitizeOptions?: MaybeRefOrGetter<SanitizeOptions>;
+}
+export declare function useMarkdownProcessor(options?: TUseMarkdownProcessorOptions): {
+    processor: ComputedRef<Processor<MdastRoot, MdastRoot, Root, undefined, undefined>>;
+};
+export declare function createProcessor(options?: {
+    prePlugins?: PluggableList;
+    rehypePlugins?: PluggableList;
+    rehypeOptions?: Omit<TRehypeOptions, 'file'>;
+    sanitize?: boolean;
+    sanitizeOptions?: SanitizeOptions;
+}): Processor<any, any, any, any, any>;

package/dist/types/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './useComponents';
+export * from './useHighlight';
+export * from './useMarkdown';
+export * from './useMermaid';
+export * from './usePlugins';
+export * from './useTheme';

package/dist/types/hooks/useComponents.d.ts

@@ -0,0 +1,21 @@
+import type { CodeBlockAction } from '../components/CodeBlock/types';
+import type { MermaidAction } from '../components/Mermaid/types';
+type ShikiThemeName = 'vitesse-light' | 'vitesse-dark' | 'github-light' | 'github-dark' | 'nord' | 'one-dark-pro' | string;
+interface UseComponentsOptions {
+    codeXRender?: Record<string, any>;
+    isDark?: boolean;
+    shikiTheme?: [ShikiThemeName, ShikiThemeName];
+    enableAnimate?: boolean;
+    showCodeBlockHeader?: boolean;
+    stickyCodeBlockHeader?: boolean;
+    codeMaxHeight?: string;
+    codeBlockActions?: CodeBlockAction[];
+    mermaidActions?: MermaidAction[];
+    mermaidConfig?: Record<string, any>;
+}
+declare function useComponents(props?: UseComponentsOptions): {
+    code: (raw: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+};
+export { useComponents };

package/dist/types/hooks/useHighlight.d.ts

@@ -0,0 +1,26 @@
+import { type Ref, type MaybeRef, type CSSProperties } from 'vue';
+interface HighlightToken {
+    content?: string;
+    color?: string;
+    fontStyle?: 'italic' | null;
+    fontWeight?: 'normal' | 'bold' | null;
+    htmlStyle?: Record<string, string>;
+}
+interface StreamingHighlightResult {
+    colorReplacements?: Record<string, string>;
+    lines: HighlightToken[][];
+    preStyle?: CSSProperties;
+}
+interface UseHighlightOptions {
+    language: MaybeRef<string>;
+    theme?: string | Ref<string>;
+    colorReplacements?: Record<string, string>;
+}
+export declare function useHighlight(text: Ref<string>, options: UseHighlightOptions): {
+    streaming: Ref<StreamingHighlightResult | undefined, StreamingHighlightResult | undefined>;
+    lines: import("vue").ComputedRef<HighlightToken[][]>;
+    preStyle: import("vue").ComputedRef<CSSProperties | undefined>;
+    isLoading: Ref<boolean, boolean>;
+    error: Ref<Error | null, Error | null>;
+};
+export {};

package/dist/types/hooks/useMarkdown.d.ts

@@ -0,0 +1,2 @@
+export declare function useProcessMarkdown(markdown: string): string;
+export declare function preprocessLaTeX(markdown: string): string;

package/dist/types/hooks/useMermaid.d.ts

@@ -0,0 +1,22 @@
+import type { Ref } from 'vue';
+import type { MermaidZoomControls, UseMermaidZoomOptions, UseMermaidResult } from '../components/Mermaid/types';
+export declare function downloadSvgAsPng(svg: string): void;
+interface UseMermaidOptions {
+    id?: string;
+    theme?: 'default' | 'dark' | 'forest' | 'neutral' | string;
+    config?: any;
+    container?: HTMLElement | Ref<HTMLElement | null> | null;
+}
+type UseMermaidOptionsInput = UseMermaidOptions | Ref<UseMermaidOptions>;
+/**
+ * 同步检查缓存状态（不触发检测）
+ * @returns 缓存状态，null 表示未检测
+ */
+export declare function getMermaidAvailableCache(): boolean | null;
+/**
+ * 检测 mermaid 是否可用（全局缓存，只检测一次）
+ */
+export declare function checkMermaidAvailable(): Promise<boolean>;
+export declare function useMermaid(content: string | Ref<string>, options?: UseMermaidOptionsInput): UseMermaidResult;
+export declare function useMermaidZoom(options: UseMermaidZoomOptions): MermaidZoomControls;
+export {};

package/dist/types/hooks/usePlugins.d.ts

@@ -0,0 +1,8 @@
+import type { Pluggable } from 'unified';
+declare function usePlugins(props: any): {
+    rehypePlugins: import("vue").ComputedRef<Pluggable[]>;
+    remarkPlugins: import("vue").ComputedRef<(Pluggable | {
+        plugins: Pluggable[];
+    })[]>;
+};
+export { usePlugins };

package/dist/types/hooks/useTheme.d.ts

@@ -0,0 +1,25 @@
+import { type Ref } from 'vue';
+export type ThemeMode = 'light' | 'dark' | 'auto';
+export type ShikiThemeName = string;
+export declare const themeMap: {
+    readonly light: "vitesse-light";
+    readonly dark: "vitesse-dark";
+};
+export interface UseThemeOptions {
+    mode?: ThemeMode | Ref<ThemeMode>;
+    theme?: ShikiThemeName | Ref<ShikiThemeName | undefined>;
+    lightTheme?: ShikiThemeName;
+    darkTheme?: ShikiThemeName;
+}
+export interface UseThemeReturn {
+    mode: Ref<ThemeMode>;
+    isDark: Ref<boolean>;
+    actualTheme: Ref<ShikiThemeName>;
+    setMode: (mode: ThemeMode) => void;
+    toggleMode: () => void;
+}
+/**
+ * 主题管理 Hook
+ * 支持 light/dark/auto 模式切换
+ */
+export declare function useTheme(options?: UseThemeOptions): UseThemeReturn;

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * x-markdown-vue 主入口
+ *
+ * 本库使用显式导出以优化 Tree Shaking
+ * 请根据需要按需导入，而不是导入整个库
+ */
+export { VueMarkdown, VueMarkdownAsync } from './core/components';
+export { MarkdownRenderer, MarkdownRendererAsync } from './MarkdownRender';
+export { getVNodeInfos, render, renderChildren } from './core/hast-to-vnode';
+export { createProcessor, useMarkdownProcessor } from './core/useProcessor';
+export { useComponents } from './hooks/useComponents';
+export { useHighlight } from './hooks/useHighlight';
+export { useProcessMarkdown, preprocessLaTeX } from './hooks/useMarkdown';
+export { useMermaid } from './hooks/useMermaid';
+export { usePlugins } from './hooks/usePlugins';
+export { useTheme } from './hooks/useTheme';
+export type * from './core/types';
+export type { CodeLineProps } from './components/CodeLine/types';
+export type { CodeBlockProps } from './components/CodeBlock/types';
+export type { MermaidProps } from './components/Mermaid/types';
+export type { MarkdownContext } from './MarkdownRender/types';

package/dist/types/plugins/rehypePlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Root } from 'hast';
+export declare function rehypeAnimatedPlugin(): (tree: Root) => void;

package/dist/x-markdown.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index-DtKeGkdv.cjs");exports.MarkdownRenderer=e.MarkdownRenderer,exports.MarkdownRendererAsync=e.MarkdownRendererAsync,exports.VueMarkdown=e.VueMarkdown,exports.VueMarkdownAsync=e.VueMarkdownAsync,exports.createProcessor=e.createProcessor,exports.getVNodeInfos=e.getVNodeInfos,exports.preprocessLaTeX=e.preprocessLaTeX,exports.render=e.render,exports.renderChildren=e.renderChildren,exports.useComponents=e.useComponents,exports.useHighlight=e.useHighlight,exports.useMarkdownProcessor=e.useMarkdownProcessor,exports.useMermaid=e.useMermaid,exports.usePlugins=e.usePlugins,exports.useProcessMarkdown=e.useProcessMarkdown,exports.useTheme=e.useTheme;
+//# sourceMappingURL=x-markdown.cjs.js.map

package/dist/x-markdown.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-markdown.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}