@coderminer/vue-markdown 0.0.0-stage → 1.0.1

package/dist/components/MarkdownTableCell.d.ts

@@ -0,0 +1,20 @@
+import { MarkdownNode } from '../core/types';
+type __VLS_Props = {
+    node: MarkdownNode;
+    children?: MarkdownNode[];
+    align?: string;
+    scope?: string;
+};
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MarkdownTableCell.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/MarkdownTableCell-eiCJe847.js";

package/dist/components/MarkdownTableRow.d.ts

@@ -0,0 +1,18 @@
+import { MarkdownNode } from '../core/types';
+type __VLS_Props = {
+    node: MarkdownNode;
+    children?: MarkdownNode[];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MarkdownTableRow.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/MarkdownTableRow-DuJaPntg.js";

package/dist/components/MarkdownTableSection.d.ts

@@ -0,0 +1,18 @@
+import { MarkdownNode } from '../core/types';
+type __VLS_Props = {
+    node: MarkdownNode;
+    children?: MarkdownNode[];
+};
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MarkdownTableSection.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/MarkdownTableSection-PFHz-R33.js";

package/dist/components/MarkdownTaskItem.d.ts

@@ -0,0 +1,20 @@
+import { MarkdownNode } from '../core/types';
+type __VLS_Props = {
+    node: MarkdownNode;
+    children?: MarkdownNode[];
+    checked?: boolean;
+    disabled?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MarkdownTaskItem.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/MarkdownTaskItem-BcmKo1lk.js";

package/dist/components/MarkdownToc.d.ts

@@ -0,0 +1,36 @@
+import { MarkdownComponentValue, TocItem } from '../core/types';
+type __VLS_Props = {
+    items: TocItem[];
+    activeId?: string;
+    label?: string;
+    tocItem?: MarkdownComponentValue;
+    /** Maximum heading level to show. `0` or omitted means every level. */
+    tocDepth?: number;
+};
+declare function navigate(id: string): void;
+declare var __VLS_2: {
+    item: TocItem;
+    active: boolean;
+    navigate: typeof navigate;
+};
+type __VLS_Slots = {} & {
+    'toc-item'?: (props: typeof __VLS_2) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    navigate: (id: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNavigate?: ((id: string) => any) | undefined;
+}>, {
+    tocItem: string | object | ((...args: never[]) => unknown);
+    label: string;
+    activeId: string;
+    tocDepth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MarkdownToc.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/MarkdownToc-DHWWoH6t.js";

package/dist/components/MarkdownTocItem.d.ts

@@ -0,0 +1,14 @@
+import { TocItem } from '../core/types';
+type __VLS_Props = {
+    item: TocItem;
+    active?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    navigate: (id: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNavigate?: ((id: string) => any) | undefined;
+}>, {
+    active: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/MarkdownTocItem.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/MarkdownTocItem-DT9mR3vL.js";

package/dist/components/MermaidBlock.d.ts

@@ -0,0 +1,50 @@
+import { MarkdownNode, MarkdownTheme, MermaidAction, MermaidRenderResult, MermaidRenderer } from '../core/types';
+type __VLS_Props = {
+    node?: MarkdownNode;
+    source?: string;
+    renderer?: MermaidRenderer;
+    theme?: MarkdownTheme;
+    showErrors?: boolean;
+    enableZoom?: boolean;
+    allowFullscreen?: boolean;
+    compact?: boolean;
+    actions?: MermaidAction[];
+};
+declare function render(): Promise<void>;
+declare function copy(): Promise<void>;
+declare function exportPng(): Promise<void>;
+declare function downloadSvg(): void;
+declare function toggleFullscreen(next?: boolean): Promise<void>;
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {
+    render: typeof render;
+    copy: typeof copy;
+    exportPng: typeof exportPng;
+    downloadSvg: typeof downloadSvg;
+    toggleFullscreen: typeof toggleFullscreen;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (message: string) => any;
+    action: (key: string) => any;
+    rendered: (result: MermaidRenderResult) => any;
+    fullscreen: (active: boolean) => any;
+    copy: (source: string) => any;
+    export: (format: "svg" | "png") => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: ((message: string) => any) | undefined;
+    onAction?: ((key: string) => any) | undefined;
+    onRendered?: ((result: MermaidRenderResult) => any) | undefined;
+    onFullscreen?: ((active: boolean) => any) | undefined;
+    onCopy?: ((source: string) => any) | undefined;
+    onExport?: ((format: "svg" | "png") => any) | undefined;
+}>, {
+    source: string;
+    theme: MarkdownTheme;
+    actions: MermaidAction[];
+    compact: boolean;
+    node: MarkdownNode;
+    renderer: MermaidRenderer;
+    showErrors: boolean;
+    enableZoom: boolean;
+    allowFullscreen: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/MermaidBlock.js

@@ -0,0 +1 @@
+export { r as default } from "../chunks/render-DAqK0w5J.js";

package/dist/components/MermaidLiveEditor.d.ts

@@ -0,0 +1,44 @@
+import { DiagnosticFormatter, MarkdownDiagnostic, MermaidRenderer } from '../core/types';
+type __VLS_Props = {
+    modelValue?: string;
+    debounce?: number;
+    theme?: 'light' | 'dark' | 'auto' | 'custom';
+    renderer?: MermaidRenderer;
+    diagnosticsFormatter?: DiagnosticFormatter;
+    compact?: boolean;
+    rawDetails?: boolean;
+    autoFocus?: boolean;
+    initialRatio?: number;
+    minRatio?: number;
+};
+declare function toggleFullscreen(): Promise<void>;
+declare function focus(): void;
+/** Apply the current editor value to the preview without waiting for debounce. */
+declare function refreshPreview(): void;
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {
+    focus: typeof focus;
+    refreshPreview: typeof refreshPreview;
+    toggleFullscreen: typeof toggleFullscreen;
+    getDiagnostics: () => MarkdownDiagnostic[];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (diagnostic: MarkdownDiagnostic) => any;
+    preview: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: ((diagnostic: MarkdownDiagnostic) => any) | undefined;
+    onPreview?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    theme: "custom" | "light" | "dark" | "auto";
+    diagnosticsFormatter: DiagnosticFormatter;
+    autoFocus: boolean;
+    compact: boolean;
+    renderer: MermaidRenderer;
+    modelValue: string;
+    debounce: number;
+    rawDetails: boolean;
+    initialRatio: number;
+    minRatio: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/MermaidLiveEditor.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/MermaidLiveEditor-1TKkI5bp.js";

package/dist/components/VueSyntaxHighlighter.d.ts

@@ -0,0 +1,39 @@
+import { HighlightLine, MarkdownDiagnostic, MarkdownHighlighter, MarkdownTheme } from '../core/types';
+type __VLS_Props = {
+    source: string;
+    language?: string;
+    theme?: MarkdownTheme;
+    highlighter?: MarkdownHighlighter;
+    lineNumbers?: boolean;
+    highlightLines?: HighlightLine[];
+    maxLines?: number;
+    virtual?: boolean;
+    virtualThreshold?: number;
+    lineHeight?: number;
+    delay?: number;
+};
+declare function copy(): Promise<void>;
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {
+    copy: typeof copy;
+    getHighlighted: () => import('..').HighlightResult;
+    highlighted: import('vue').ShallowRef<import('..').HighlightResult>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (diagnostic: MarkdownDiagnostic) => any;
+    copy: (source: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: ((diagnostic: MarkdownDiagnostic) => any) | undefined;
+    onCopy?: ((source: string) => any) | undefined;
+}>, {
+    theme: MarkdownTheme;
+    highlighter: MarkdownHighlighter;
+    lineHeight: number;
+    language: string;
+    lineNumbers: boolean;
+    highlightLines: HighlightLine[];
+    maxLines: number;
+    virtual: boolean;
+    virtualThreshold: number;
+    delay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VueSyntaxHighlighter.js

@@ -0,0 +1 @@
+export { t as default } from "../chunks/VueSyntaxHighlighter-BWpCO-cX.js";

package/dist/components/codeRegion.d.ts

@@ -0,0 +1,14 @@
+import { ComputedRef } from 'vue';
+import { MarkdownComponentValue } from '../core/types';
+export interface UseCodeRegionOptions {
+    standalone?: () => boolean;
+    ignoreRegion?: () => boolean;
+}
+/**
+ * Resolve `regions.codeBlock` for a code component.
+ *
+ * A region that renders `CodeBlock` (or `MarkdownCode`) internally must not
+ * re-enter itself. The provider below marks descendants as already inside a
+ * code region, so nested code components always render their own default.
+ */
+export declare function useCodeBlockRegion(options?: UseCodeRegionOptions): ComputedRef<MarkdownComponentValue | undefined>;

package/dist/components/config.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { MarkdownConfig } from '../core/types';
+export declare const MARKDOWN_CONFIG: InjectionKey<ComputedRef<MarkdownConfig>>;
+/** Read the nearest provider configuration, or an empty configuration. */
+export declare function useMarkdownConfig(): ComputedRef<MarkdownConfig>;
+/** Provide a configuration to descendant renderers and providers. */
+export declare function provideMarkdownConfig(config: ComputedRef<MarkdownConfig>): void;

package/dist/components/context.d.ts

@@ -0,0 +1,45 @@
+import { InjectionKey, Slot, VNodeChild } from 'vue';
+import { DiagnosticFormatter, MarkdownComponentValue, MarkdownDocument, MarkdownExternalLinkTarget, MarkdownHighlighter, MarkdownLabels, MarkdownNode, MarkdownRegionComponents, MarkdownTheme, MathEngine, MermaidRenderer } from '../core/types';
+export interface LinkClickPayload {
+    url: string;
+    target: string;
+    node: MarkdownNode;
+    event: MouseEvent;
+}
+export interface CustomTagClickPayload {
+    tag: string;
+    props: Record<string, unknown>;
+    node: MarkdownNode;
+    event: MouseEvent;
+}
+export interface TaskChangePayload {
+    checked: boolean;
+    node: MarkdownNode;
+}
+export interface RenderContext {
+    components: Record<string, MarkdownComponentValue>;
+    nodeComponents?: Record<string, MarkdownComponentValue>;
+    regions?: MarkdownRegionComponents;
+    document?: MarkdownDocument;
+    theme?: MarkdownTheme;
+    labels: MarkdownLabels;
+    linkTarget: string;
+    externalLinkTarget: MarkdownExternalLinkTarget;
+    highlighter?: MarkdownHighlighter;
+    mathEngine?: MathEngine;
+    mermaidRenderer?: MermaidRenderer;
+    diagnosticsFormatter?: DiagnosticFormatter;
+    /** Host-authored region slots keyed by documented slot name. */
+    slots?: Readonly<Record<string, Slot | undefined>>;
+    /** Render a host slot, falling back to the default region when empty. */
+    renderHostSlot(name: string, props: Record<string, unknown>, fallback: () => VNodeChild): VNodeChild;
+    onLinkClick(payload: LinkClickPayload): void;
+    onCustomTagClick(payload: CustomTagClickPayload): void;
+    onTaskChange(payload: TaskChangePayload): void;
+    onRenderError?(diagnostic: import('../core/types').MarkdownDiagnostic): void;
+    onMathError?(diagnostic: import('../core/types').MarkdownDiagnostic): void;
+}
+export declare const RENDER_CONTEXT: InjectionKey<RenderContext>;
+export declare function useRenderContext(): RenderContext;
+/** True when a slot produced no meaningful output and the default should win. */
+export declare function isEmptySlotContent(value: VNodeChild): boolean;

package/dist/components/index.d.ts

@@ -0,0 +1,42 @@
+export { default as MarkdownRenderer } from './MarkdownRenderer';
+export { default as MarkdownConfigProvider } from './MarkdownConfigProvider';
+export { default as MarkdownRoot } from './MarkdownRoot';
+export { default as MarkdownContent } from './MarkdownContent';
+export { default as MarkdownToc } from './MarkdownToc';
+export { default as MarkdownTocItem } from './MarkdownTocItem';
+export { default as MarkdownError } from './MarkdownError';
+export { default as MarkdownEmpty } from './MarkdownEmpty';
+export { default as MarkdownLoading } from './MarkdownLoading';
+export { default as MarkdownParagraph } from './MarkdownParagraph';
+export { default as MarkdownHeading } from './MarkdownHeading';
+export { default as MarkdownEmphasis } from './MarkdownEmphasis';
+export { default as MarkdownStrong } from './MarkdownStrong';
+export { default as MarkdownStrikethrough } from './MarkdownStrikethrough';
+export { default as MarkdownLink } from './MarkdownLink';
+export { default as MarkdownImage } from './MarkdownImage';
+export { default as MarkdownList } from './MarkdownList';
+export { default as MarkdownListItem } from './MarkdownListItem';
+export { default as MarkdownBlockquote } from './MarkdownBlockquote';
+export { default as MarkdownHorizontalRule } from './MarkdownHorizontalRule';
+export { default as MarkdownTable } from './MarkdownTable';
+export { default as MarkdownTableSection } from './MarkdownTableSection';
+export { default as MarkdownTableRow } from './MarkdownTableRow';
+export { default as MarkdownTableCell } from './MarkdownTableCell';
+export { default as MarkdownInlineCode } from './MarkdownInlineCode';
+export { default as MarkdownCode } from './MarkdownCode';
+export { default as CodeBlock } from './CodeBlock';
+export { default as VueSyntaxHighlighter } from './VueSyntaxHighlighter';
+export { default as MermaidBlock } from './MermaidBlock';
+export { default as MermaidLiveEditor } from './MermaidLiveEditor';
+export { default as MarkdownTaskItem } from './MarkdownTaskItem';
+export { default as MarkdownFootnoteReference } from './MarkdownFootnoteReference';
+export { default as MarkdownFootnotes } from './MarkdownFootnotes';
+export { default as MarkdownMath } from './MarkdownMath';
+export { default as MarkdownMermaid } from './MarkdownMermaid';
+export { default as MarkdownBreak } from './MarkdownBreak';
+export { default as MarkdownHtml } from './MarkdownHtml';
+export { default as MarkdownCustomTag } from './MarkdownCustomTag';
+export { default as MarkdownChildren } from './MarkdownChildren';
+export * from './context';
+export * from './config';
+export * from './types';

package/dist/components/index.js

@@ -0,0 +1,38 @@
+import { n as e, r as t, t as n } from "../chunks/config-aRYo2R8_.js";
+import { n as r, r as i, t as a } from "../chunks/context-8NfW6fxI.js";
+import { a as o, i as s, n as c, r as l } from "../chunks/render-DAqK0w5J.js";
+import { t as u } from "../chunks/MarkdownCode-B1k9tmW5.js";
+import { t as d } from "../chunks/MarkdownBlockquote-DVXziX2t.js";
+import { t as f } from "../chunks/MarkdownBreak-BwCi2Itt.js";
+import { t as p } from "../chunks/MarkdownCustomTag-lZJHsD6f.js";
+import { t as m } from "../chunks/MarkdownEmphasis-CppivOEu.js";
+import { t as h } from "../chunks/MarkdownHeading-DaNcP0_6.js";
+import { t as g } from "../chunks/MarkdownHorizontalRule-QNe_cuUI.js";
+import { t as _ } from "../chunks/MarkdownImage-BRy76svs.js";
+import { t as v } from "../chunks/MarkdownInlineCode-MXZYFwex.js";
+import { t as y } from "../chunks/MarkdownLink-Dbx3NwgV.js";
+import { t as b } from "../chunks/MarkdownList-BJ-_C71k.js";
+import { t as x } from "../chunks/MarkdownListItem-Z1EHIY26.js";
+import { t as S } from "../chunks/MarkdownFootnoteReference-Dy3Khwyj.js";
+import { t as C } from "../chunks/MarkdownFootnotes-BRPzkbXv.js";
+import { t as w } from "../chunks/MarkdownParagraph-BxLSmSaG.js";
+import { t as T } from "../chunks/MarkdownStrikethrough-CblvbqDk.js";
+import { t as E } from "../chunks/MarkdownTaskItem-BcmKo1lk.js";
+import { t as D } from "../chunks/MarkdownStrong-uU5MzAoJ.js";
+import { t as O } from "../chunks/MarkdownTable-DmBTg_CR.js";
+import { t as k } from "../chunks/MarkdownTableCell-eiCJe847.js";
+import { t as A } from "../chunks/MarkdownTableRow-DuJaPntg.js";
+import { t as j } from "../chunks/MarkdownTableSection-PFHz-R33.js";
+import { n as M, t as N } from "../chunks/MarkdownRenderer-OlkdsvI3.js";
+import { t as P } from "../chunks/MarkdownContent-BAK6dqo7.js";
+import { t as F } from "../chunks/MarkdownEmpty-Av5k6bqa.js";
+import { t as I } from "../chunks/MarkdownError-C0sPs5W0.js";
+import { t as L } from "../chunks/MarkdownLoading-D-RYtXxf.js";
+import { t as R } from "../chunks/MarkdownRoot-DEE6iVfh.js";
+import { t as z } from "../chunks/MarkdownTocItem-DT9mR3vL.js";
+import { t as B } from "../chunks/MarkdownToc-DHWWoH6t.js";
+import { t as V } from "../chunks/MarkdownConfigProvider-5N3ylrIu.js";
+import { t as H } from "../chunks/VueSyntaxHighlighter-BWpCO-cX.js";
+import { t as U } from "../chunks/MermaidLiveEditor-1TKkI5bp.js";
+import { t as W } from "../chunks/MarkdownHtml-66lYkvwM.js";
+export { o as CodeBlock, n as MARKDOWN_CONFIG, d as MarkdownBlockquote, f as MarkdownBreak, M as MarkdownChildren, u as MarkdownCode, V as MarkdownConfigProvider, P as MarkdownContent, p as MarkdownCustomTag, m as MarkdownEmphasis, F as MarkdownEmpty, I as MarkdownError, S as MarkdownFootnoteReference, C as MarkdownFootnotes, h as MarkdownHeading, g as MarkdownHorizontalRule, W as MarkdownHtml, _ as MarkdownImage, v as MarkdownInlineCode, y as MarkdownLink, b as MarkdownList, x as MarkdownListItem, L as MarkdownLoading, s as MarkdownMath, c as MarkdownMermaid, w as MarkdownParagraph, N as MarkdownRenderer, R as MarkdownRoot, T as MarkdownStrikethrough, D as MarkdownStrong, O as MarkdownTable, k as MarkdownTableCell, A as MarkdownTableRow, j as MarkdownTableSection, E as MarkdownTaskItem, B as MarkdownToc, z as MarkdownTocItem, l as MermaidBlock, U as MermaidLiveEditor, a as RENDER_CONTEXT, H as VueSyntaxHighlighter, r as isEmptySlotContent, e as provideMarkdownConfig, t as useMarkdownConfig, i as useRenderContext };

package/dist/components/render.d.ts

@@ -0,0 +1,9 @@
+import { Component, VNodeChild } from 'vue';
+import { MarkdownNode } from '../core/types';
+import { RenderContext } from './context';
+/** Element tags that map to a semantic node kind. */
+export declare const TAG_TO_KIND: Record<string, string>;
+export declare function resolveTagComponent(tag: string, ctx: RenderContext): Component | string | undefined;
+export declare function resolveKindComponent(kind: string, ctx: RenderContext): Component | string | undefined;
+export declare function renderNode(node: MarkdownNode, ctx: RenderContext): VNodeChild;
+export declare function renderNodes(nodes: readonly MarkdownNode[], ctx: RenderContext): VNodeChild[];

package/dist/components/scroll-lock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Lock page scrolling for every fullscreen surface on the page. The original
+ * overflow is restored only when the last surface releases the lock.
+ */
+export declare function lockPageScroll(): void;
+/** Release one page-scroll lock. Safe to call when the caller owns no lock. */
+export declare function unlockPageScroll(): void;

package/dist/components/types.d.ts

@@ -0,0 +1,61 @@
+import { Component, VNodeChild } from 'vue';
+import { MarkdownDiagnostic, MarkdownDocument, MarkdownNode, MarkdownRegionComponents, MermaidRenderResult, SearchChangePayload, TocItem } from '../core/types';
+import { CustomTagClickPayload, LinkClickPayload, RenderContext, TaskChangePayload } from './context';
+/**
+ * Typed event map for `MarkdownRenderer`. Payloads are library-owned values:
+ * document models, diagnostics, primitives, or plain records. They never
+ * contain Vue components, VNodes, DOM nodes, or processor objects. Interaction
+ * events also carry the originating DOM `MouseEvent` so listeners can cancel
+ * the default behavior. Use the map with `defineEmits` in host wrappers when a
+ * single typed contract is preferable to learning each event shape separately.
+ */
+export interface MarkdownRendererEvents {
+    'update:source': [source: string];
+    'toc-change': [toc: TocItem[]];
+    'link-click': [payload: LinkClickPayload];
+    'custom-tag-click': [payload: CustomTagClickPayload];
+    'task-change': [payload: TaskChangePayload];
+    'search-change': [payload: SearchChangePayload];
+    'math-error': [diagnostic: MarkdownDiagnostic];
+    'render-error': [diagnostic: MarkdownDiagnostic];
+    ready: [document: MarkdownDocument];
+}
+/**
+ * Typed event map for `MermaidBlock` and `MarkdownMermaid`. Primitive payloads
+ * are used for lightweight UI notifications; `rendered` carries the structured
+ * render result so a listener can read the sanitized nodes and SVG.
+ */
+export interface MermaidBlockEvents {
+    rendered: [result: MermaidRenderResult];
+    error: [message: string];
+    copy: [source: string];
+    export: [format: 'png' | 'svg'];
+    fullscreen: [active: boolean];
+    action: [key: string];
+}
+export type VueMarkdownTagComponents = Record<string, Component | string | undefined>;
+export interface MarkdownNodeRenderContext {
+    node: MarkdownNode;
+    kind: MarkdownNode['kind'];
+    /** The element/custom tag, or `undefined` for semantic nodes. */
+    tag?: string;
+    /** A safe, always-present attribute map for element/custom nodes. */
+    attrs: Record<string, string>;
+    key: string;
+    children: () => VNodeChild;
+    defaultRender: () => VNodeChild;
+    context: RenderContext;
+}
+export type MarkdownNodeRenderer = (context: MarkdownNodeRenderContext) => VNodeChild;
+export type VueMarkdownNodeComponents = Record<string, Component | string | MarkdownNodeRenderer | undefined>;
+export type VueMarkdownRegionComponents = {
+    [K in keyof MarkdownRegionComponents]?: Component | string | undefined;
+};
+/** Exposed instance API of `MarkdownRenderer`. */
+export interface MarkdownRendererInstance {
+    scrollToHeading(id: string, options?: ScrollIntoViewOptions): void;
+    getDocument(): MarkdownDocument | undefined;
+    getToc(): TocItem[];
+    refresh(): Promise<void>;
+    updateSource(source: string): void;
+}

package/dist/composables/useActiveHeading.d.ts

@@ -0,0 +1,12 @@
+import { MaybeRefOrGetter } from 'vue';
+export interface UseActiveHeadingOptions {
+    /**
+     * Scope heading lookups to one rendered document root. Pass this when a
+     * page contains multiple renderers that may generate the same heading IDs.
+     */
+    root?: MaybeRefOrGetter<Element | Document | null | undefined>;
+}
+/** Find an element by id inside a document or a scoped root element. */
+export declare function findElementById(scope: Element | Document, id: string): HTMLElement | null;
+/** Tracks the heading currently in view without touching the DOM before mount. */
+export declare function useActiveHeading(ids: MaybeRefOrGetter<string[]>, enabled?: MaybeRefOrGetter<boolean>, options?: UseActiveHeadingOptions): import('vue').Ref<string | undefined, string | undefined>;

package/dist/composables/useCodeHighlighter.d.ts

@@ -0,0 +1,30 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from 'vue';
+import { HighlightResult, MarkdownDiagnostic, MarkdownHighlighter, MarkdownTheme } from '../core/types';
+export interface UseCodeHighlighterOptions {
+    source: MaybeRefOrGetter<string>;
+    language: MaybeRefOrGetter<string>;
+    highlighter?: MaybeRefOrGetter<MarkdownHighlighter | undefined>;
+    theme?: MaybeRefOrGetter<MarkdownTheme | undefined>;
+    /** Nearest provider or render-context theme, below the local `theme` prop. */
+    contextTheme?: MaybeRefOrGetter<MarkdownTheme | undefined>;
+    /** When false the highlighter is neither loaded nor run (for example, a region replacement). */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Optional debounce in milliseconds. */
+    delay?: MaybeRefOrGetter<number>;
+    onDiagnostic?: (diagnostic: MarkdownDiagnostic) => void;
+}
+export interface UseCodeHighlighterReturn {
+    result: ShallowRef<HighlightResult>;
+    active: ShallowRef<MarkdownHighlighter | undefined>;
+    resolvedTheme: ComputedRef<MarkdownTheme>;
+    refresh: () => Promise<void>;
+    getHighlighted: () => HighlightResult;
+}
+/**
+ * Shared highlighter state for `CodeBlock` and `VueSyntaxHighlighter`.
+ *
+ * Keeping the lazy default adapter, theme mapping, readiness loading, and
+ * diagnostics in one place prevents the two public components from drifting
+ * apart as adapters are added.
+ */
+export declare function useCodeHighlighter(options: UseCodeHighlighterOptions): UseCodeHighlighterReturn;

package/dist/composables/useLineWindow.d.ts

@@ -0,0 +1,38 @@
+import { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+import { HighlightLine, MarkdownNode } from '../core/types';
+export interface VisibleLine {
+    index: number;
+    nodes: MarkdownNode[];
+}
+export interface UseLineWindowOptions {
+    nodes: MaybeRefOrGetter<readonly MarkdownNode[]>;
+    source: MaybeRefOrGetter<string>;
+    maxLines?: MaybeRefOrGetter<number>;
+    virtual?: MaybeRefOrGetter<boolean>;
+    virtualThreshold?: MaybeRefOrGetter<number>;
+    lineHeight?: MaybeRefOrGetter<number>;
+    highlightLines?: MaybeRefOrGetter<readonly HighlightLine[] | undefined>;
+}
+export interface UseLineWindowReturn {
+    highlightedLines: ComputedRef<MarkdownNode[][]>;
+    expanded: Ref<boolean>;
+    truncatable: ComputedRef<boolean>;
+    totalLines: ComputedRef<number>;
+    virtualActive: ComputedRef<boolean>;
+    startLine: ComputedRef<number>;
+    endLine: ComputedRef<number>;
+    visibleLines: ComputedRef<VisibleLine[]>;
+    lineHeight: ComputedRef<number>;
+    scrollRef: Ref<HTMLElement | undefined>;
+    onScroll: (event: Event) => void;
+    measure: () => void;
+    toggle: () => void;
+    isHighlightedLine: (index: number) => boolean;
+}
+/**
+ * Shared line windowing used by `CodeBlock` and `VueSyntaxHighlighter`.
+ *
+ * The composable owns only presentation state: split lines, truncation, and
+ * the visible window. Highlighting itself stays in `useCodeHighlighter`.
+ */
+export declare function useLineWindow(options: UseLineWindowOptions): UseLineWindowReturn;