@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/vue/log/tlog-session.d.ts

@@ -0,0 +1,81 @@
+import type { Ref } from "vue";
+import type { TLogViewHandle } from "../components/TLogView.js";
+import type { TLogSavedSearch } from "./use-tlog-search-controller.js";
+export type StorageLike = Readonly<{
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+}>;
+export type TLogViewSessionState = Readonly<{
+    scrollTop: number;
+    firstLineIndex: number;
+    visualIndexMode: "estimated" | "exact";
+    search?: Readonly<{
+        query: string;
+        mode: "text" | "regex";
+        caseSensitive: boolean;
+        wholeWord: boolean;
+        regexFlags?: string;
+        currentMatchIndex: number;
+        history?: readonly string[];
+        savedSearches?: readonly TLogSavedSearch[];
+    }>;
+    ui?: Readonly<{
+        resultsPage?: number;
+        linksPanelActiveIndex?: number;
+        wrap?: boolean;
+        ansi?: boolean;
+        links?: boolean;
+        keyboardLinks?: boolean;
+    }>;
+}>;
+export type TLogViewSessionBindings = Readonly<{
+    logView: Ref<TLogViewHandle | null>;
+    visualIndexMode?: Ref<"estimated" | "exact">;
+    wrap?: Ref<boolean>;
+    ansi?: Ref<boolean>;
+    links?: Ref<boolean>;
+    keyboardLinks?: Ref<boolean>;
+    search?: Readonly<{
+        query: Ref<string>;
+        mode: Ref<"text" | "regex">;
+        caseSensitive: Ref<boolean>;
+        wholeWord: Ref<boolean>;
+        regexFlags: Ref<string>;
+        searchHistory?: Ref<readonly string[]>;
+        savedSearches?: Ref<readonly TLogSavedSearch[]>;
+        updateQuery: (value: string) => void;
+        updateMode: (value: "text" | "regex") => void;
+        updateCaseSensitive: (value: boolean) => void;
+        updateWholeWord: (value: boolean) => void;
+        updateRegexFlags: (value: string) => void;
+        setSearchHistory?: (value: readonly string[]) => void;
+        setSavedSearches?: (value: readonly TLogSavedSearch[]) => void;
+        clearSearch: () => void;
+        selectMatch: (matchIndex: number) => boolean;
+        resultsPage?: Readonly<{
+            state: Ref<Readonly<{
+                page: number;
+            }>>;
+            setPage: (page: number) => void;
+        }>;
+    }>;
+    linkController?: Readonly<{
+        activeIndex: Ref<number>;
+        focusVisibleLink: (visibleIndex: number) => boolean;
+        clearFocus: () => void;
+    }>;
+}>;
+export declare function serializeTLogViewSessionState(state: TLogViewSessionState): string;
+export declare function deserializeTLogViewSessionState(value: string | null | undefined): TLogViewSessionState | null;
+export declare function createTLogViewSessionStore(options?: {
+    storageKey?: string;
+    storage?: StorageLike | null;
+}): {
+    state: Ref<TLogViewSessionState | null>;
+    load: () => TLogViewSessionState | null;
+    save: (state: TLogViewSessionState) => void;
+    clear: () => void;
+};
+export declare function captureTLogViewSessionState(bindings: TLogViewSessionBindings): TLogViewSessionState | null;
+export declare function restoreTLogViewSessionState(bindings: TLogViewSessionBindings, state: TLogViewSessionState | null): boolean;

package/dist/vue/log/tlog-theme.d.ts

@@ -0,0 +1,68 @@
+import type { Style } from "../../core/types.js";
+import type { TLogSearchBar } from "../components/TLogSearchBar.js";
+import type { TLogSearchPager } from "../components/TLogSearchPager.js";
+import type { TLogVirtualLinksPanel } from "../components/TLogVirtualLinksPanel.js";
+import type { TLogVirtualSearchResults } from "../components/TLogVirtualSearchResults.js";
+import type { TLogMinimap } from "../components/TLogMinimap.js";
+import type { TLogScrollbar } from "../components/TLogScrollbar.js";
+import type { TLogView } from "../components/TLogView.js";
+import type { TLogKeymap } from "./tlog-keymap.js";
+export type TLogTheme = Readonly<{
+    base?: Style;
+    error?: Style;
+    warning?: Style;
+    info?: Style;
+    search?: Readonly<{
+        match?: Style;
+        currentMatch?: Style;
+        input?: Style;
+        error?: Style;
+        active?: Style;
+        disabled?: Style;
+    }>;
+    links?: Readonly<{
+        link?: Style;
+        focused?: Style;
+        active?: Style;
+        disabled?: Style;
+    }>;
+    scrollbar?: Readonly<{
+        track?: Style;
+        thumb?: Style;
+        measuring?: Style;
+        marker?: Style;
+        currentMarker?: Style;
+    }>;
+    minimap?: Readonly<{
+        density?: Style;
+        viewport?: Style;
+        marker?: Style;
+        currentMarker?: Style;
+        estimated?: Style;
+    }>;
+}>;
+export type TLogUiPreset = Readonly<{
+    theme: TLogTheme;
+    keymap: TLogKeymap;
+}>;
+type SearchBarThemeProps = Partial<InstanceType<typeof TLogSearchBar>["$props"]>;
+type SearchResultsThemeProps = Partial<InstanceType<typeof TLogVirtualSearchResults>["$props"]>;
+type SearchPagerThemeProps = Partial<InstanceType<typeof TLogSearchPager>["$props"]>;
+type LinksPanelThemeProps = Partial<InstanceType<typeof TLogVirtualLinksPanel>["$props"]>;
+type ScrollbarThemeProps = Partial<InstanceType<typeof TLogScrollbar>["$props"]>;
+type MinimapThemeProps = Partial<InstanceType<typeof TLogMinimap>["$props"]>;
+type LogViewThemeProps = Partial<InstanceType<typeof TLogView>["$props"]>;
+export declare const tlogDefaultTheme: TLogTheme;
+export declare const tlogDarkTheme: TLogTheme;
+export declare const tlogHighContrastTheme: TLogTheme;
+export declare const tlogDefaultPreset: TLogUiPreset;
+export declare const tlogDarkPreset: TLogUiPreset;
+export declare const tlogHighContrastPreset: TLogUiPreset;
+export declare function resolveTLogViewTheme(theme: TLogTheme): LogViewThemeProps;
+export declare function resolveTLogSearchBarTheme(theme: TLogTheme): SearchBarThemeProps;
+export declare function resolveTLogSearchResultsTheme(theme: TLogTheme): SearchResultsThemeProps;
+export declare function resolveTLogSearchPagerTheme(theme: TLogTheme): SearchPagerThemeProps;
+export declare function resolveTLogLinksPanelTheme(theme: TLogTheme): LinksPanelThemeProps;
+export declare function resolveTLogScrollbarTheme(theme: TLogTheme): ScrollbarThemeProps;
+export declare function resolveTLogMinimapTheme(theme: TLogTheme): MinimapThemeProps;
+export {};

package/dist/vue/log/types.d.ts

@@ -0,0 +1,43 @@
+import type { Ref } from "vue";
+export interface TLogDataSource {
+    lineCount(): number;
+    getLine(index: number): string;
+    getLineKey?: (index: number) => string | number;
+    firstLineIndex?: () => number;
+}
+export type CreateAppendOnlyLogStoreOptions = Readonly<{
+    maxLines?: number;
+}>;
+export type AppendOnlyLogStore = Readonly<{
+    source: TLogDataSource;
+    version: Ref<number>;
+    appendLine: (line: string) => void;
+    appendLines: (lines: readonly string[]) => void;
+    appendChunk: (chunk: string) => void;
+    replaceTail: (text: string) => void;
+    clear: () => void;
+}>;
+export type TLogViewVisualIndexStatus = "estimated" | "measuring" | "exact";
+export type TLogViewVisualIndexOptions = Readonly<{
+    /**
+     * Max time spent measuring wrapped visual rows in one scheduler frame.
+     * Default: 4ms.
+     */
+    measureBudgetMs?: number;
+    /**
+     * Optional retained-window cap for exact visual index work.
+     * Undefined means measure the whole retained source window.
+     */
+    maxMeasuredLines?: number;
+}>;
+export type TLogViewScrollPayload = Readonly<{
+    scrollTop: number;
+    atBottom: boolean;
+    lineCount: number;
+    estimatedVisualRowCount: number;
+    visualRowCount: number;
+    measuredVisualRowCount: number;
+    measuredLineCount: number;
+    visualIndexStatus: TLogViewVisualIndexStatus;
+    firstLineIndex?: number;
+}>;

package/dist/vue/log/use-tlog-link-controller.d.ts

@@ -0,0 +1,31 @@
+import type { Ref } from "vue";
+import type { TLogViewHandle, TLogViewLinkActivatePayload, TLogViewLinkClickPayload } from "../components/TLogView.js";
+import type { TLogLinkPanelItem } from "../components/TLogLinksPanel.js";
+import type { TLogViewPlugin } from "./tlog-plugins.js";
+export type TLogLinkActionSource = "click" | "keyboard" | "programmatic" | "panel";
+export type TLogLinkAction = Readonly<{
+    href: string;
+    text: string;
+    source: TLogLinkActionSource;
+    absoluteLineIndex: number;
+    index: number;
+    startCell: number;
+    endCell: number;
+}>;
+export type UseTLogLinkControllerOptions = Readonly<{
+    onAction?: (action: TLogLinkAction) => void;
+    plugins?: readonly TLogViewPlugin[];
+}>;
+export declare function useTLogLinkController(logView: Ref<TLogViewHandle | null>, options?: UseTLogLinkControllerOptions): {
+    visibleLinks: Ref<readonly TLogLinkPanelItem[]>;
+    activeIndex: Ref<number>;
+    refresh: () => void;
+    focusVisibleLink: (visibleIndex: number) => boolean;
+    focusNextLink: () => boolean;
+    focusPreviousLink: () => boolean;
+    clearFocus: () => void;
+    activateVisibleLink: (visibleIndex: number) => boolean;
+    activateFocusedLink: () => boolean;
+    handleLinkClick: (payload: TLogViewLinkClickPayload) => void;
+    handleLinkActivate: (payload: TLogViewLinkActivatePayload) => void;
+};

package/dist/vue/log/use-tlog-retained-index.d.ts

@@ -0,0 +1,26 @@
+import type { Ref } from "vue";
+import type { TLogMinimapDensityBucket } from "../components/TLogMinimap.js";
+import type { TLogViewHandle } from "../components/TLogView.js";
+import type { TLogDataSource } from "./types.js";
+import type { TLogViewExternalLink, TLogViewExternalMarker, TLogViewPlugin } from "./tlog-plugins.js";
+export type TLogIndexStatus = "idle" | "indexing" | "done" | "error";
+export type TLogDiagnosticMarker = TLogViewExternalMarker;
+export type TLogIndexedLink = TLogViewExternalLink;
+export type TLogRetainedIndexOptions = Readonly<{
+    links?: boolean;
+    levels?: boolean;
+    urls?: boolean;
+    budgetMs?: number;
+    maxItems?: number;
+    bucketCount?: number;
+    allowFileUrls?: boolean;
+    plugins?: readonly TLogViewPlugin[];
+}>;
+export declare function useTLogRetainedIndex(logView: Ref<TLogViewHandle | null>, source: Ref<TLogDataSource>, version: Ref<number>, options?: TLogRetainedIndexOptions): {
+    status: Ref<TLogIndexStatus>;
+    links: Ref<readonly TLogIndexedLink[]>;
+    diagnostics: Ref<readonly TLogDiagnosticMarker[]>;
+    density: Ref<readonly TLogMinimapDensityBucket[]>;
+    refresh: () => void;
+    cancel: () => void;
+};

package/dist/vue/log/use-tlog-search-controller.d.ts

@@ -0,0 +1,51 @@
+import type { Ref } from "vue";
+import type { TLogSearchBarMode, TLogSearchBarState } from "../components/TLogSearchBar.js";
+import type { TLogViewHandle, TLogViewScrollMetrics, TLogViewSearchMarker, TLogViewSearchState } from "../components/TLogView.js";
+import type { UseTLogSearchResultsPageOptions } from "./use-tlog-search-results-page.js";
+import { useTLogSearchResultsPage } from "./use-tlog-search-results-page.js";
+export type TLogSavedSearch = Readonly<{
+    id: string;
+    label?: string;
+    query: string;
+    mode: TLogSearchBarMode;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    regexFlags?: string;
+}>;
+export type UseTLogSearchControllerOptions = Readonly<UseTLogSearchResultsPageOptions & {
+    initialQuery?: string;
+    initialMode?: TLogSearchBarMode;
+    initialCaseSensitive?: boolean;
+    initialWholeWord?: boolean;
+    initialRegexFlags?: string;
+    maxHistory?: number;
+    initialSavedSearches?: readonly TLogSavedSearch[];
+}>;
+export declare function useTLogSearchController(logView: Ref<TLogViewHandle | null>, options?: UseTLogSearchControllerOptions): {
+    query: Ref<string>;
+    mode: Ref<TLogSearchBarMode>;
+    caseSensitive: Ref<boolean>;
+    wholeWord: Ref<boolean>;
+    regexFlags: Ref<string>;
+    searchState: Ref<TLogViewSearchState>;
+    searchBarState: Ref<TLogSearchBarState>;
+    resultsPage: ReturnType<typeof useTLogSearchResultsPage>;
+    markers: Ref<readonly TLogViewSearchMarker[]>;
+    metrics: Ref<TLogViewScrollMetrics | null>;
+    searchHistory: Ref<readonly string[]>;
+    savedSearches: Ref<readonly TLogSavedSearch[]>;
+    updateQuery: (value: string) => void;
+    updateMode: (value: TLogSearchBarMode) => void;
+    updateCaseSensitive: (value: boolean) => void;
+    updateWholeWord: (value: boolean) => void;
+    updateRegexFlags: (value: string) => void;
+    nextMatch: () => void;
+    previousMatch: () => void;
+    clearSearch: () => void;
+    selectMatch: (matchIndex: number) => boolean;
+    refresh: () => void;
+    saveCurrentSearch: (label?: string) => TLogSavedSearch | null;
+    applySavedSearch: (id: string) => boolean;
+    setSearchHistory: (value: readonly string[]) => void;
+    setSavedSearches: (value: readonly TLogSavedSearch[]) => void;
+};

package/dist/vue/log/use-tlog-search-results-page.d.ts

@@ -0,0 +1,31 @@
+import type { Ref } from "vue";
+import type { TLogSearchResultItem } from "../components/TLogSearchResults.js";
+import type { TLogViewHandle, TLogViewSearchError, TLogViewSearchState } from "../components/TLogView.js";
+export type UseTLogSearchResultsPageOptions = Readonly<{
+    pageSize?: number;
+    includePreview?: boolean;
+    previewWidth?: number;
+    contextCells?: number;
+}>;
+export type TLogSearchResultsPageState = Readonly<{
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    matchCount: number;
+    offset: number;
+    activeIndex: number;
+    currentMatchIndex: number;
+    status: TLogViewSearchState["status"];
+    error: TLogViewSearchError | null;
+    results: readonly TLogSearchResultItem[];
+}>;
+export declare function useTLogSearchResultsPage(logView: Ref<TLogViewHandle | null>, options?: UseTLogSearchResultsPageOptions): {
+    state: Ref<TLogSearchResultsPageState>;
+    refresh: () => void;
+    clear: (status?: TLogViewSearchState["status"], error?: TLogViewSearchError | null) => void;
+    setPage: (page: number) => void;
+    nextPage: () => void;
+    previousPage: () => void;
+    syncPageToCurrentMatch: () => void;
+    selectResult: (matchIndex: number) => boolean;
+};

package/dist/vue/log/use-tlog-virtual-search-results.d.ts

@@ -0,0 +1,22 @@
+import type { Ref } from "vue";
+import type { TLogSearchResultItem } from "../components/TLogSearchResults.js";
+import type { TLogViewHandle, TLogViewSearchError, TLogViewSearchState } from "../components/TLogView.js";
+export type UseTLogVirtualSearchResultsOptions = Readonly<{
+    includePreview?: boolean;
+    previewWidth?: number;
+    contextCells?: number;
+}>;
+export type TLogVirtualSearchResultsState = Readonly<{
+    itemCount: number;
+    itemVersion: number;
+    activeIndex: number;
+    currentMatchIndex: number;
+    status: TLogViewSearchState["status"];
+    error: TLogViewSearchError | null;
+}>;
+export declare function useTLogVirtualSearchResults(logView: Ref<TLogViewHandle | null>, options?: UseTLogVirtualSearchResultsOptions): {
+    state: Ref<TLogVirtualSearchResultsState>;
+    refresh: () => void;
+    getItem: (index: number) => TLogSearchResultItem | null;
+    select: (matchIndex: number) => boolean;
+};

package/dist/vue/markdown/ast.d.ts

@@ -0,0 +1,3 @@
+import { type TuiMarkdownTheme } from "./theme.js";
+import type { TuiMarkdownBlock, TuiMarkdownNode } from "./types.js";
+export declare function markdownAstToBlocks(nodes: readonly TuiMarkdownNode[], theme: TuiMarkdownTheme): readonly TuiMarkdownBlock[];

package/dist/vue/markdown/block-source.d.ts

@@ -0,0 +1,22 @@
+import { type TuiMarkdownParser } from "./parser.js";
+import type { TuiMarkdownThemeOverrides } from "./theme.js";
+import type { TuiMarkdownBlock } from "./types.js";
+export type TuiMarkdownBlockSourceSnapshot = Readonly<{
+    version: number;
+    blocks: readonly TuiMarkdownBlock[];
+}>;
+export type TuiMarkdownBlockSource = Readonly<{
+    version: number;
+    blocks: readonly TuiMarkdownBlock[];
+    appendDelta: (text: string) => void;
+    replaceTailBlock: (text: string) => void;
+    finalizeBlock: () => void;
+    clear: () => void;
+    snapshot: () => TuiMarkdownBlockSourceSnapshot;
+}>;
+export type TuiMarkdownBlockSourceOptions = Readonly<{
+    parser?: TuiMarkdownParser;
+    customHtmlTags?: readonly string[];
+    theme?: TuiMarkdownThemeOverrides;
+}>;
+export declare function createMarkdownBlockSource(options?: TuiMarkdownBlockSourceOptions): TuiMarkdownBlockSource;

package/dist/vue/markdown/document.d.ts

@@ -0,0 +1,20 @@
+import { type TuiMarkdownParser } from "./parser.js";
+import { type TuiMarkdownThemeOverrides } from "./theme.js";
+import type { TuiMarkdownBlock, TuiMarkdownNode, TuiMarkdownVisualRow } from "./types.js";
+import type { WidthProvider } from "../../core/buffer/width.js";
+/**
+ * This helper always builds visual rows from the full source string. Components
+ * that need streaming reuse can call buildMarkdownBlocks and cache block layout.
+ */
+export declare function buildMarkdownBlocks(content: string, parser: TuiMarkdownParser, options?: Readonly<{
+    final?: boolean;
+    theme?: TuiMarkdownThemeOverrides;
+}>): Readonly<{
+    nodes: readonly TuiMarkdownNode[];
+    blocks: readonly TuiMarkdownBlock[];
+}>;
+export declare function buildMarkdownVisualRows(content: string, width: number, parser: TuiMarkdownParser, options?: Readonly<{
+    final?: boolean;
+    theme?: TuiMarkdownThemeOverrides;
+    widthProvider?: WidthProvider;
+}>): readonly TuiMarkdownVisualRow[];

package/dist/vue/markdown/layout.d.ts

@@ -0,0 +1,21 @@
+import type { WidthProvider } from "../../core/buffer/width.js";
+import type { TuiMarkdownBlock, TuiMarkdownVisualRow } from "./types.js";
+export type TuiMarkdownLayoutCache = Readonly<{
+    width: number;
+    widthProvider?: WidthProvider;
+    entries: ReadonlyMap<string, TuiMarkdownLayoutCacheEntry>;
+}>;
+export type TuiMarkdownLayoutOptions = Readonly<{
+    widthProvider?: WidthProvider;
+}>;
+type TuiMarkdownLayoutCacheEntry = Readonly<{
+    signature: string;
+    rows: readonly TuiMarkdownVisualRow[];
+}>;
+export declare function layoutMarkdownBlock(block: TuiMarkdownBlock, width: number): readonly TuiMarkdownVisualRow[];
+export declare function layoutMarkdownBlocksCached(blocks: readonly TuiMarkdownBlock[], width: number, previous?: TuiMarkdownLayoutCache): Readonly<{
+    rows: readonly TuiMarkdownVisualRow[];
+    cache: TuiMarkdownLayoutCache;
+}>;
+export declare function layoutMarkdownBlocks(blocks: readonly TuiMarkdownBlock[], width: number, options?: TuiMarkdownLayoutOptions): readonly TuiMarkdownVisualRow[];
+export {};

package/dist/vue/markdown/parser.d.ts

@@ -0,0 +1,11 @@
+import type { TuiMarkdownNode } from "./types.js";
+export interface TuiMarkdownParseConfig {
+    streaming?: boolean;
+    customHtmlTags?: readonly string[];
+}
+export interface TuiMarkdownParser {
+    parse: (content: string, final: boolean) => TuiMarkdownNode[];
+}
+export declare function sanitizeMarkdownLink(url: string): string | null;
+export declare function isSafeMarkdownLink(url: string): boolean;
+export declare function createTuiMarkdownParser(config?: TuiMarkdownParseConfig): TuiMarkdownParser;

package/dist/vue/markdown/render.d.ts

@@ -0,0 +1,10 @@
+import type { Style, Terminal } from "../../core/types.js";
+import type { TuiMarkdownVisualRow } from "./types.js";
+export declare function paintMarkdownVisualRow(terminal: Terminal, row: TuiMarkdownVisualRow | undefined, options: Readonly<{
+    x: number;
+    y: number;
+    w: number;
+    clipStart?: number;
+    baseStyle: Style;
+    clear?: boolean;
+}>): void;

package/dist/vue/markdown/theme.d.ts

@@ -0,0 +1,186 @@
+import type { Style } from "../../core/types.js";
+export type TuiMarkdownTheme = Readonly<{
+    heading: readonly [Style, Style, Style, Style, Style, Style];
+    strong: Style;
+    emphasis: Style;
+    strikethrough: Style;
+    inlineCode: Style;
+    link: Style;
+    blockquote: Style;
+    listMarker: Style;
+    codeBlock: Style;
+    thematicBreak: Style;
+    html: Style;
+}>;
+export type TuiMarkdownThemeOverrides = Readonly<Partial<{
+    heading: readonly Partial<Style>[];
+    strong: Partial<Style>;
+    emphasis: Partial<Style>;
+    strikethrough: Partial<Style>;
+    inlineCode: Partial<Style>;
+    link: Partial<Style>;
+    blockquote: Partial<Style>;
+    listMarker: Partial<Style>;
+    codeBlock: Partial<Style>;
+    thematicBreak: Partial<Style>;
+    html: Partial<Style>;
+}>>;
+export declare const DEFAULT_TUI_MARKDOWN_THEME: Readonly<{
+    heading: readonly [Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>, Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>, Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>, Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>, Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>, Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>];
+    strong: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    emphasis: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    strikethrough: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    inlineCode: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    link: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    blockquote: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    listMarker: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    codeBlock: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    thematicBreak: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    html: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+}>;
+export declare function markdownThemeSignature(overrides?: TuiMarkdownThemeOverrides): string;
+export declare function resolveTuiMarkdownTheme(overrides?: TuiMarkdownThemeOverrides): TuiMarkdownTheme;