dou-ui 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/types/components/dropdown/item-components.d.ts

@@ -0,0 +1,103 @@
+export declare const DouDropdownItem: import("../..").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./dropdown").DropdownItemProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (event: MouseEvent) => any;
+        "update:checked": (checked: boolean) => any;
+    }, import("vue").PublicProps, {
+        tone: import("./dropdown").DropdownItemTone;
+        disabled: boolean;
+        checked: boolean;
+        divided: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./dropdown").DropdownItemProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        tone: import("./dropdown").DropdownItemTone;
+        disabled: boolean;
+        checked: boolean;
+        divided: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./dropdown").DropdownItemProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    "update:checked": (checked: boolean) => any;
+}, string, {
+    tone: import("./dropdown").DropdownItemTone;
+    disabled: boolean;
+    checked: boolean;
+    divided: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./dropdown").DropdownItemSlots;
+}), import("vue").HTMLAttributes>;
+export declare const DouDropdownGroup: import("../..").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./dropdown").DropdownGroupProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        divided: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./dropdown").DropdownGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+        divided: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./dropdown").DropdownGroupProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    divided: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./dropdown").DropdownGroupSlots;
+}), import("vue").HTMLAttributes>;
+export declare const DouDropdownRadioGroup: import("../..").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./dropdown").DropdownGroupProps & {
+        modelValue?: import("./dropdown").DropdownValue;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import("./dropdown").DropdownValue | undefined) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (value: import("./dropdown").DropdownValue | undefined) => any;
+    }, import("vue").PublicProps, {
+        divided: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./dropdown").DropdownGroupProps & {
+        modelValue?: import("./dropdown").DropdownValue;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import("./dropdown").DropdownValue | undefined) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        divided: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./dropdown").DropdownGroupProps & {
+    modelValue?: import("./dropdown").DropdownValue;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("./dropdown").DropdownValue | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("./dropdown").DropdownValue | undefined) => any;
+}, string, {
+    divided: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./dropdown").DropdownRadioGroupSlots;
+}), import("vue").HTMLAttributes>;

package/dist/types/components/dropdown/menu-entries.d.ts

@@ -0,0 +1,4 @@
+import type { ContextMenuEntry, ContextMenuGroup, ContextMenuItem } from '../context-menu/context-menu';
+export declare const isMenuGroup: (entry: ContextMenuEntry) => entry is ContextMenuGroup;
+/** The item with `key`, in a group or not. */
+export declare function findMenuItem(entries: ContextMenuEntry[] | undefined, key: unknown): ContextMenuItem | undefined;

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

@@ -71,6 +71,7 @@ export * from './layout';
 export * from './link';
 export * from './listbox';
 export * from './loading';
+export * from './markdown';
 export * from './marquee';
 export * from './masonry';
 export * from './menu';
@@ -97,6 +98,7 @@ export * from './sparkline';
 export * from './spinner';
 export * from './splitter';
 export * from './statistic';
+export * from './status-dot';
 export * from './steps';
 export * from './stream-text';
 export * from './switch';

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

@@ -57,8 +57,8 @@ export declare const DouLayoutAside: import("../..").WithInstall<{
         sticky: boolean;
         width: string | number;
         bordered: boolean;
-        collapsedWidth: string | number;
         collapsible: boolean;
+        collapsedWidth: string | number;
         side: "right" | "left";
     }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
@@ -77,8 +77,8 @@ export declare const DouLayoutAside: import("../..").WithInstall<{
         sticky: boolean;
         width: string | number;
         bordered: boolean;
-        collapsedWidth: string | number;
         collapsible: boolean;
+        collapsedWidth: string | number;
         side: "right" | "left";
     }>;
     __isFragment?: never;
@@ -97,8 +97,8 @@ export declare const DouLayoutAside: import("../..").WithInstall<{
     sticky: boolean;
     width: string | number;
     bordered: boolean;
-    collapsedWidth: string | number;
     collapsible: boolean;
+    collapsedWidth: string | number;
     side: "right" | "left";
 }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
     $slots: import("./layout").LayoutAsideSlots;
@@ -120,18 +120,24 @@ export declare const DouLayoutMain: import("../..").WithInstall<{
     $slots: import("./layout").LayoutSectionSlots;
 }), import("vue").HTMLAttributes>;
 export declare const DouLayoutFooter: import("../..").WithInstall<{
-    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./layout").LayoutFooterProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        bordered: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    }, Readonly<import("./layout").LayoutFooterProps> & Readonly<{}>, {}, {}, {}, {}, {
+        bordered: boolean;
+    }>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+} & import("vue").ComponentOptionsBase<Readonly<import("./layout").LayoutFooterProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    bordered: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
     $slots: import("./layout").LayoutSectionSlots;
 }), import("vue").HTMLAttributes>;
 export default DouLayout;

package/dist/types/components/layout/layout-aside.vue.d.ts

@@ -16,8 +16,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {
     sticky: boolean;
     width: string | number;
     bordered: boolean;
-    collapsedWidth: string | number;
     collapsible: boolean;
+    collapsedWidth: string | number;
     side: "right" | "left";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/components/layout/layout-footer.vue.d.ts

@@ -1,6 +1,8 @@
-import type { LayoutSectionSlots } from './layout';
+import type { LayoutFooterProps, LayoutSectionSlots } from './layout';
 type __VLS_Slots = LayoutSectionSlots;
-declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<LayoutFooterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LayoutFooterProps> & Readonly<{}>, {
+    bordered: boolean;
+}, {}, {}, {}, 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;

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

@@ -13,6 +13,10 @@ export interface LayoutHeaderProps {
     /** A hairline under the header. */
     bordered?: boolean;
 }
+export interface LayoutFooterProps {
+    /** A hairline above the footer. */
+    bordered?: boolean;
+}
 export interface LayoutAsideProps {
     /** The width when expanded. Numbers are px. */
     width?: number | string;

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

@@ -0,0 +1,58 @@
+import Markdown from './markdown.vue';
+export declare const DouMarkdown: import("../..").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./markdown").MarkdownProps> & Readonly<{
+        onDone?: (() => any) | undefined;
+    }>, import("./markdown").MarkdownExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        done: () => any;
+    }, import("vue").PublicProps, {
+        content: string;
+        smooth: boolean;
+        caret: boolean;
+        streaming: boolean;
+        speed: number;
+        linkTarget: import("./markdown").MarkdownLinkTarget;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./markdown").MarkdownProps> & Readonly<{
+        onDone?: (() => any) | undefined;
+    }>, import("./markdown").MarkdownExpose, {}, {}, {}, {
+        content: string;
+        smooth: boolean;
+        caret: boolean;
+        streaming: boolean;
+        speed: number;
+        linkTarget: import("./markdown").MarkdownLinkTarget;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./markdown").MarkdownProps> & Readonly<{
+    onDone?: (() => any) | undefined;
+}>, import("./markdown").MarkdownExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: () => any;
+}, string, {
+    content: string;
+    smooth: boolean;
+    caret: boolean;
+    streaming: boolean;
+    speed: number;
+    linkTarget: import("./markdown").MarkdownLinkTarget;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./markdown").MarkdownSlots;
+}), import("vue").HTMLAttributes>;
+export default DouMarkdown;
+export type * from './markdown';
+export { createMarkdownParser, parseMarkdown } from './parser';
+export type { MarkdownParser } from './parser';
+export { defaultSanitizeUrl } from './url';
+export type MarkdownInstance = InstanceType<typeof Markdown>;
+declare module 'vue' {
+    interface GlobalComponents {
+        DouMarkdown: typeof DouMarkdown;
+    }
+}

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

@@ -0,0 +1,251 @@
+import type { VNode } from 'vue';
+import type { ChatSource } from '../chat-sources/chat-sources';
+/** Column alignment of a table, from its delimiter row. */
+export type MarkdownAlign = 'left' | 'center' | 'right' | '';
+/** Inline content: what a paragraph, heading or table cell is made of. */
+export type MarkdownInline = 
+/** `at` is where the text starts in the source, which the reveal animation goes by. */
+{
+    type: 'text';
+    value: string;
+    at: number;
+} | {
+    type: 'strong' | 'em' | 'del';
+    children: MarkdownInline[];
+} | {
+    type: 'code';
+    value: string;
+    at: number;
+}
+/** `href` is missing while the address is still being written. */
+ | {
+    type: 'link';
+    href?: string;
+    title?: string;
+    children: MarkdownInline[];
+} | {
+    type: 'image';
+    src: string;
+    alt: string;
+    title?: string;
+}
+/** A hard line break. */
+ | {
+    type: 'break';
+}
+/** A line break inside a paragraph; `cjk` when both sides are CJK, so no space shows. */
+ | {
+    type: 'softbreak';
+    cjk?: boolean;
+};
+interface Span {
+    /** Where the block starts in the source, in UTF-16 units. Also its key. */
+    start: number;
+    /** Where it ends. */
+    end: number;
+}
+export interface MarkdownParagraph extends Span {
+    type: 'paragraph';
+    children: MarkdownInline[];
+}
+export interface MarkdownHeading extends Span {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: MarkdownInline[];
+}
+export interface MarkdownCode extends Span {
+    type: 'code';
+    /** The first word of the info string, e.g. `ts`. */
+    lang: string;
+    value: string;
+    /** The closing fence has arrived (always true for indented code). */
+    closed: boolean;
+}
+export interface MarkdownHr extends Span {
+    type: 'hr';
+}
+export interface MarkdownBlockquote extends Span {
+    type: 'blockquote';
+    children: MarkdownBlock[];
+}
+/** A custom block: `:::name title`, its content, then `:::`. */
+export interface MarkdownContainer extends Span {
+    type: 'container';
+    /** The word after the colons, e.g. `tip`. */
+    name: string;
+    /** The rest of the opening line, trimmed. */
+    title: string;
+    /** The closing fence has arrived. */
+    closed: boolean;
+    children: MarkdownBlock[];
+}
+export interface MarkdownItem extends Span {
+    type: 'item';
+    /** `true` / `false` for a task item, `null` otherwise. */
+    checked: boolean | null;
+    /** Copied from the list: a tight list shows its paragraphs without spacing. */
+    tight: boolean;
+    children: MarkdownBlock[];
+}
+export interface MarkdownList extends Span {
+    type: 'list';
+    ordered: boolean;
+    /** The number of the first item of an ordered list. */
+    startNumber: number;
+    tight: boolean;
+    children: MarkdownItem[];
+}
+export interface MarkdownRow extends Span {
+    type: 'row';
+    cells: MarkdownInline[][];
+}
+export interface MarkdownTable extends Span {
+    type: 'table';
+    align: MarkdownAlign[];
+    head: MarkdownRow;
+    rows: MarkdownRow[];
+}
+export type MarkdownBlock = MarkdownParagraph | MarkdownHeading | MarkdownCode | MarkdownHr | MarkdownBlockquote | MarkdownContainer | MarkdownList | MarkdownTable;
+/** Kinds of address `sanitizeUrl` is asked about. */
+export type MarkdownUrlKind = 'link' | 'image' | 'source';
+/** Where links open; any other string names a window or frame. */
+export type MarkdownLinkTarget = '_blank' | '_self' | '_parent' | '_top' | (string & {});
+export interface MarkdownProps {
+    /** The Markdown source. While streaming, everything received so far. */
+    content?: string;
+    /** More is still coming: unfinished syntax at the end is shown in its likely final form. */
+    streaming?: boolean;
+    /**
+     * Reveal new content gradually and fade it in. Turned off, it shows as it
+     * arrives, still at most once a frame. Content that is already there when
+     * the component mounts is shown at once either way.
+     */
+    smooth?: boolean;
+    /** The slowest reveal, in characters per second. A larger backlog is caught up faster. */
+    speed?: number;
+    /** Show a blinking caret after the last character while streaming. */
+    caret?: boolean;
+    /** Sources for citations: `[1]` in the text shows as a ChatCitation for the first one. */
+    sources?: ChatSource[];
+    /**
+     * Where links with a full address (`https://…`, `//…`) open. Relative
+     * addresses and anchors always open in place.
+     */
+    linkTarget?: MarkdownLinkTarget;
+    /**
+     * Checks the address of a link, image or citation source and returns the
+     * one to use, or `undefined` to drop it (a link keeps its text, a source
+     * its title). By default only http(s), mailto, tel, relative addresses and
+     * anchors are kept: see `defaultSanitizeUrl`.
+     */
+    sanitizeUrl?: (url: string, kind: MarkdownUrlKind) => string | undefined;
+}
+export interface MarkdownEmits {
+    /** Everything is shown and `streaming` is off. */
+    done: [];
+}
+/**
+ * Every slot replaces one kind of node. `children` is what would be drawn
+ * inside it, new text still fading in; draw it with
+ * `<component :is="children" />`.
+ */
+export interface MarkdownSlots {
+    paragraph?: (props: {
+        node: MarkdownParagraph;
+        children: VNode;
+    }) => unknown;
+    heading?: (props: {
+        node: MarkdownHeading;
+        level: number;
+        children: VNode;
+    }) => unknown;
+    blockquote?: (props: {
+        node: MarkdownBlockquote;
+        children: VNode;
+    }) => unknown;
+    list?: (props: {
+        node: MarkdownList;
+        children: VNode;
+    }) => unknown;
+    /** A list item; `children` leaves out the task checkbox. */
+    item?: (props: {
+        node: MarkdownItem;
+        checked: boolean | null;
+        children: VNode;
+    }) => unknown;
+    /** A table; `children` is the default `<table>`, e.g. to wrap it. */
+    table?: (props: {
+        node: MarkdownTable;
+        children: VNode;
+    }) => unknown;
+    hr?: (props: {
+        node: MarkdownHr;
+    }) => unknown;
+    /**
+     * A fenced code block. `streaming` is on while its closing fence has not
+     * arrived; hand it to CodeBlock so that only whole lines are highlighted.
+     */
+    code?: (props: MarkdownCodeSlotProps) => unknown;
+    /** A code block in one language, e.g. `code-mermaid`; before `code`. */
+    [name: `code-${string}`]: ((props: MarkdownCodeSlotProps) => unknown) | undefined;
+    /** A `:::name` block. Without a slot, `tip`, `info`, `note`, `warning` and `danger` show as an Alert. */
+    container?: (props: MarkdownContainerSlotProps) => unknown;
+    /** A container of one name, e.g. `container-tip`; before `container`. */
+    [name: `container-${string}`]: ((props: MarkdownContainerSlotProps) => unknown) | undefined;
+    /**
+     * A link. `href` has passed `sanitizeUrl`, and is missing while the
+     * address is still being written or was dropped. `external` for a full
+     * address, which opens at `linkTarget`.
+     */
+    link?: (props: {
+        node: Extract<MarkdownInline, {
+            type: 'link';
+        }>;
+        href: string | undefined;
+        title: string | undefined;
+        external: boolean;
+        children: VNode;
+    }) => unknown;
+    /** An image whose address has passed `sanitizeUrl`. */
+    image?: (props: {
+        src: string;
+        alt: string;
+        title?: string;
+    }) => unknown;
+    /** A citation such as `[1]`, with the source from `sources` (its `url` checked). */
+    citation?: (props: {
+        index: number;
+        source: ChatSource;
+    }) => unknown;
+    'inline-code'?: (props: {
+        code: string;
+    }) => unknown;
+    strong?: (props: {
+        children: VNode;
+    }) => unknown;
+    em?: (props: {
+        children: VNode;
+    }) => unknown;
+    del?: (props: {
+        children: VNode;
+    }) => unknown;
+}
+export interface MarkdownCodeSlotProps {
+    node: MarkdownCode;
+    code: string;
+    lang: string;
+    streaming: boolean;
+}
+export interface MarkdownContainerSlotProps {
+    node: MarkdownContainer;
+    name: string;
+    title: string;
+    /** Its closing fence has not arrived yet. */
+    streaming: boolean;
+    children: VNode;
+}
+export interface MarkdownExpose {
+    /** Show everything received so far at once. */
+    flush: () => void;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import type { MarkdownExpose, MarkdownProps, MarkdownSlots } from './markdown';
+type __VLS_Slots = MarkdownSlots;
+declare const __VLS_base: import("vue").DefineComponent<MarkdownProps, MarkdownExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: () => any;
+}, string, import("vue").PublicProps, Readonly<MarkdownProps> & Readonly<{
+    onDone?: (() => any) | undefined;
+}>, {
+    content: string;
+    smooth: boolean;
+    caret: boolean;
+    streaming: boolean;
+    speed: number;
+    linkTarget: import("./markdown").MarkdownLinkTarget;
+}, {}, {}, {}, 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/types/components/markdown/parse-block.d.ts

@@ -0,0 +1,61 @@
+import type { MarkdownAlign } from './markdown';
+import { type MarkdownRefs } from './parse-inline';
+export type BlockKind = 'document' | 'blockquote' | 'container' | 'list' | 'item' | 'paragraph' | 'heading' | 'code' | 'hr' | 'table';
+/** A source line of a leaf: its text and where that text starts in the source. */
+export interface SourceLine {
+    text: string;
+    at: number;
+    /** Where the whole line starts. */
+    line: number;
+}
+export interface BNode {
+    kind: BlockKind;
+    parent: BNode | null;
+    children: BNode[];
+    open: boolean;
+    start: number;
+    end: number;
+    startLine: number;
+    endLine: number;
+    lines: SourceLine[];
+    level: number;
+    fence: {
+        ch: string;
+        len: number;
+        indent: number;
+    } | null;
+    info: string;
+    closed: boolean;
+    ordered: boolean;
+    marker: string;
+    startNumber: number;
+    offset: number;
+    padding: number;
+    align: MarkdownAlign[];
+}
+/** Cells of a table row, with where each starts in `text`. */
+export declare function splitRow(text: string): {
+    text: string;
+    index: number;
+}[];
+export interface BlockParseResult {
+    /** The top-level blocks. */
+    blocks: BNode[];
+    /** How many leading blocks can no longer change. */
+    stable: number;
+    /** Where to start the next parse, when `stable` blocks are kept. */
+    resume: number;
+    /** Link reference definitions found. */
+    refs: MarkdownRefs;
+    /** Labels defined inside the stable blocks. */
+    stableLabels: string[];
+    /** The leaf still being written, which shows unfinished syntax in its likely final form. */
+    tip: BNode | null;
+    /** Whether the last line ends in a newline. */
+    complete: boolean;
+}
+/**
+ * Parse the block structure of `source` from offset `from` (a point where
+ * nothing is open). With `partial`, the source is the start of a stream.
+ */
+export declare function parseBlocks(source: string, from?: number, partial?: boolean): BlockParseResult;

package/dist/types/components/markdown/parse-inline.d.ts

@@ -0,0 +1,19 @@
+import type { MarkdownInline } from './markdown';
+/** Link reference definitions, keyed by normalized label. */
+export type MarkdownRefs = Map<string, {
+    href: string;
+    title?: string;
+}>;
+export declare function isCjk(char: string | undefined): boolean;
+/** Backslash escapes and entities, as in link destinations and titles. */
+export declare function unescapeMarkdown(text: string): string;
+export declare function normalizeLabel(label: string): string;
+/**
+ * Parse inline Markdown.
+ *
+ * `at` maps an index in `text` to its offset in the whole source. With
+ * `partial`, `text` is the end of a stream: unfinished syntax at the end is
+ * shown in its likely final form, and markers that may still turn into
+ * something are hidden.
+ */
+export declare function parseInline(text: string, at: (index: number) => number, refs: MarkdownRefs, partial?: boolean): MarkdownInline[];

package/dist/types/components/markdown/parser.d.ts

@@ -0,0 +1,22 @@
+import type { MarkdownBlock } from './markdown';
+export interface MarkdownParseOptions {
+    /** The stream is over: unfinished syntax at the end is read as it stands. */
+    final?: boolean;
+}
+export interface MarkdownParser {
+    /**
+     * Parse `source`, a longer version of the last one while streaming.
+     * Blocks that cannot change any more are not parsed again, and every
+     * block that is unchanged since the last update is the same object.
+     * Pass `{ final: true }` once the stream is over.
+     */
+    update: (source: string, options?: MarkdownParseOptions) => MarkdownBlock[];
+    /** How many leading blocks of the last update can no longer change. */
+    readonly stable: number;
+    /** Forget everything parsed so far. */
+    reset: () => void;
+}
+/** An incremental parser for a Markdown stream. */
+export declare function createMarkdownParser(): MarkdownParser;
+/** Parse a whole Markdown document. Works anywhere, without a DOM. */
+export declare function parseMarkdown(source: string): MarkdownBlock[];