@sayknow-cli/tui 0.3.12 → 0.3.13

package/src/utils.ts

@@ -5,6 +5,7 @@ import {
 	sliceWithWidth as nativeSliceWithWidth,
 	truncateLinesToWidth as nativeTruncateLinesToWidth,
 	truncateToWidth as nativeTruncateToWidth,
+	visibleWidth as nativeVisibleWidth,
 	visibleWidths as nativeVisibleWidths,
 	wrapTextWithAnsi as nativeWrapTextWithAnsi,
 	type SliceResult,
@@ -163,10 +164,142 @@ const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 export function getSegmenter(): Intl.Segmenter {
 	return segmenter;
 }
+
+export interface ViewportAnchorSpan {
+	graphemeStart: number;
+	graphemeEnd: number;
+	cellStart: number;
+	cellEnd: number;
+}
+
+export interface ViewportAnchorAnnotation {
+	text: string;
+	nextGrapheme: number;
+	nextCell: number;
+	token: string;
+}
+
+// APC marker for viewport anchors. Must NOT start with "\x1b_G": that is the
+// Kitty graphics prefix and TERMINAL.isImageLine() would misclassify every
+// annotated line as an image line, which skips wrapping (issue: assistant
+// prose overflowing the terminal on Kitty-protocol terminals).
+export const VIEWPORT_ANCHOR_PREFIX = "\x1b_ASKC_ANCHOR:";
+const VIEWPORT_ANCHOR_SUFFIX = "\x1b\\";
+
+function ansiSequenceEnd(text: string, start: number): number {
+	if (text[start] !== "\x1b" || start + 1 >= text.length) return start;
+	const kind = text[start + 1];
+	if (kind === "[") {
+		let index = start + 2;
+		while (index < text.length) {
+			const code = text.charCodeAt(index++);
+			if (code >= 0x40 && code <= 0x7e) return index;
+		}
+		return text.length;
+	}
+	if (kind === "]" || kind === "_" || kind === "P" || kind === "^" || kind === "X") {
+		const bel = text.indexOf("\x07", start + 2);
+		const st = text.indexOf("\x1b\\", start + 2);
+		if (bel < 0) return st < 0 ? text.length : st + 2;
+		if (st < 0) return bel + 1;
+		return Math.min(bel + 1, st + 2);
+	}
+	return Math.min(text.length, start + 2);
+}
+
+/**
+ * Tag every visible grapheme with an APC marker that survives ANSI-aware
+ * wrapping. The marker contains source grapheme and monotonic cell offsets.
+ */
+export function annotateViewportAnchorGraphemes(
+	text: string,
+	startGrapheme = 0,
+	startCell = 0,
+	token = crypto.randomUUID(),
+): ViewportAnchorAnnotation {
+	let result = "";
+	let grapheme = startGrapheme;
+	let cell = startCell;
+	let textStart = 0;
+	const appendVisible = (visible: string): void => {
+		for (const part of segmenter.segment(visible)) {
+			if (part.segment === "\n" || part.segment === "\r") {
+				result += part.segment;
+				continue;
+			}
+			const cellEnd = cell + Math.max(1, visibleWidth(part.segment));
+			result += `${part.segment}${VIEWPORT_ANCHOR_PREFIX}${token}:${grapheme}:${grapheme + 1}:${cell}:${cellEnd}${VIEWPORT_ANCHOR_SUFFIX}`;
+			grapheme += 1;
+			cell = cellEnd;
+		}
+	};
+	for (let index = 0; index < text.length; ) {
+		if (text[index] !== "\x1b") {
+			index += 1;
+			continue;
+		}
+		appendVisible(text.slice(textStart, index));
+		const end = ansiSequenceEnd(text, index);
+		result += text.slice(index, end);
+		index = end;
+		textStart = end;
+	}
+	appendVisible(text.slice(textStart));
+	return { text: result, nextGrapheme: grapheme, nextCell: cell, token };
+}
+
+/** Remove viewport anchor markers and return the exact marked span for each row. */
+export function extractViewportAnchorRows(
+	lines: readonly string[],
+	token: string,
+): { lines: string[]; spans: Array<ViewportAnchorSpan | null> } {
+	const markerRegex = new RegExp(`\\x1b_ASKC_ANCHOR:${token}:(\\d+):(\\d+):(\\d+):(\\d+)\\x1b\\\\`, "g");
+	const cleanLines: string[] = [];
+	const spans: Array<ViewportAnchorSpan | null> = [];
+	for (const line of lines) {
+		let span: ViewportAnchorSpan | null = null;
+		const clean = line.replace(markerRegex, (_marker, start, end, cellStart, cellEnd) => {
+			const candidate = {
+				graphemeStart: Number(start),
+				graphemeEnd: Number(end),
+				cellStart: Number(cellStart),
+				cellEnd: Number(cellEnd),
+			};
+			if (!span) {
+				span = candidate;
+			} else {
+				span.graphemeStart = Math.min(span.graphemeStart, candidate.graphemeStart);
+				span.graphemeEnd = Math.max(span.graphemeEnd, candidate.graphemeEnd);
+				span.cellStart = Math.min(span.cellStart, candidate.cellStart);
+				span.cellEnd = Math.max(span.cellEnd, candidate.cellEnd);
+			}
+			return "";
+		});
+		cleanLines.push(clean);
+		spans.push(span);
+	}
+	return { lines: cleanLines, spans };
+}
 function normalizeForWidth(str: string): string {
 	const normalized = str.normalize("NFC");
 	return normalized === str ? str : normalized;
 }
+
+function hasUnpairedSurrogate(str: string): boolean {
+	for (let index = 0; index < str.length; index++) {
+		const code = str.charCodeAt(index);
+		if (code >= 0xd800 && code <= 0xdbff) {
+			const next = str.charCodeAt(index + 1);
+			if (next >= 0xdc00 && next <= 0xdfff) {
+				index += 1;
+				continue;
+			}
+			return true;
+		}
+		if (code >= 0xdc00 && code <= 0xdfff) return true;
+	}
+	return false;
+}
 export function visibleWidthRaw(str: string): number {
 	if (!str) {
 		return 0;
@@ -191,8 +324,8 @@ export function visibleWidthRaw(str: string): number {
 		return str.length + tabCount * (getCachedTabWidth() - 1);
 	}
 	const normalized = normalizeForWidth(str);
-	if (tabCount === 0) return Bun.stringWidth(normalized);
-	return Bun.stringWidth(normalized.replaceAll("\t", " ".repeat(getCachedTabWidth())));
+	const text = tabCount === 0 ? normalized : normalized.replaceAll("\t", " ".repeat(getCachedTabWidth()));
+	return nativeVisibleWidth(text, getCachedTabWidth());
 }
 
 /**
@@ -205,15 +338,18 @@ export function visibleWidth(str: string): number {
 
 export function visibleWidthsNative(lines: readonly string[]): number[] {
 	__textHelperPerfCounters.visibleWidthsCalls += 1;
-	return nativeVisibleWidths(
-		lines.map(line => (typeof line === "string" ? line : String(line ?? ""))),
-		getCachedTabWidth(),
-	);
+	const safeLines = lines.map(line => (typeof line === "string" ? line : String(line ?? "")));
+	const widths = nativeVisibleWidths(safeLines, getCachedTabWidth());
+	for (let index = 0; index < safeLines.length; index++) {
+		const line = safeLines[index]!;
+		if (hasUnpairedSurrogate(line)) widths[index] = visibleWidthRaw(line);
+	}
+	return widths;
 }
 
 export function visibleWidths(lines: readonly string[]): number[] {
-	void visibleWidthsNative(lines);
-	return lines.map(line => visibleWidth(typeof line === "string" ? line : String(line ?? "")));
+	if (!renderMetrics.enabled) return visibleWidthsNative(lines);
+	return recordTextHelper("text.visibleWidths", () => visibleWidthsNative(lines));
 }
 
 const THAI_LAO_AM_REGEX = /[\u0e33\u0eb3]/;

package/dist/types/animation-scheduler.d.ts

@@ -1,13 +0,0 @@
-export type AnimationCadence = 16 | 80;
-type AnimationCallback = (now: number) => void;
-export interface AnimationRegistration {
-    unregister(): void;
-}
-export declare function registerAnimationCallback(callback: AnimationCallback, cadence?: AnimationCadence): AnimationRegistration;
-export declare const __animationSchedulerTestHooks: {
-    getActiveTimerCount(cadence?: AnimationCadence): number;
-    getRegistrantCount(cadence?: AnimationCadence): number;
-    getStartedTimerCount(cadence?: AnimationCadence): number;
-    reset(): void;
-};
-export {};

package/dist/types/autocomplete.d.ts

@@ -1,83 +0,0 @@
-export declare function getSlashCommandMatchRank(query: string, commandName: string): number;
-export declare function extractSlashCommandTokenPrefix(text: string): string | null;
-export interface AutocompleteItem {
-    value: string;
-    label: string;
-    description?: string;
-    /** Dim hint text shown inline after cursor when this item is selected */
-    hint?: string;
-}
-type Awaitable<T> = T | Promise<T>;
-export interface SlashCommand {
-    name: string;
-    description?: string;
-    argumentHint?: string;
-    /**
-     * Higher values surface first in autocomplete, ahead of fuzzy-score ordering.
-     * Use this to pin first-class commands (e.g. bundled SKC skills) to the top.
-     */
-    priority?: number;
-    getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
-    /** Return inline hint text for the current argument state (shown as dim ghost text after cursor) */
-    getInlineHint?(argumentText: string): string | null;
-}
-export interface AutocompleteProvider {
-    /** Get autocomplete suggestions for current text/cursor position */
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null>;
-    /** Apply the selected item and return new text + cursor position */
-    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
-        lines: string[];
-        cursorLine: number;
-        cursorCol: number;
-        onApplied?: () => void;
-    };
-    /** Get inline hint text to show as dim ghost text after the cursor */
-    getInlineHint?(lines: string[], cursorLine: number, cursorCol: number): string | null;
-    /** Synchronously try to complete a slash command at the start of a line (no async I/O). */
-    /** Returns matched items and the full prefix, or null if not applicable. */
-    trySyncSlashCompletion?(textBeforeCursor: string): {
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null;
-    /**
-     * Synchronously try to expand text immediately before the cursor (no async I/O).
-     * Called after every single-character insert. Implementations MUST cheaply
-     * early-return when the trailing context cannot trigger them.
-     * Returns the number of characters to delete immediately before the cursor
-     * and the literal string to insert in their place, or null to leave the
-     * buffer untouched.
-     */
-    trySyncInlineReplace?(textBeforeCursor: string): {
-        replaceLen: number;
-        insert: string;
-    } | null;
-}
-export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
-    #private;
-    constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string);
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null>;
-    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
-        lines: string[];
-        cursorLine: number;
-        cursorCol: number;
-    };
-    invalidateDirCache(dir?: string): void;
-    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null>;
-    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
-    /** Get inline hint text for slash commands with subcommand hints */
-    getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null;
-    trySyncSlashCompletion(textBeforeCursor: string): {
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null;
-}
-export {};

package/dist/types/bracketed-paste.d.ts

@@ -1,26 +0,0 @@
-export type PasteResult = {
-    handled: false;
-} | {
-    handled: true;
-    pasteContent?: string;
-    remaining: string;
-};
-/**
- * Handles bracketed paste mode buffering for terminal input components.
- *
- * Bracketed paste mode wraps pasted content between start (\x1b[200~) and
- * end (\x1b[201~) markers, which may arrive split across multiple chunks.
- * This class buffers incoming data and assembles complete paste payloads.
- */
-export declare class BracketedPasteHandler {
-    #private;
-    /**
-     * Process incoming terminal data for bracketed paste sequences.
-     *
-     * @returns `{ handled: false }` if the data contains no paste sequence and
-     *          should be processed normally. `{ handled: true }` if the data was
-     *          consumed by paste buffering — `pasteContent` is set when a complete
-     *          paste has been assembled; omitted when still buffering.
-     */
-    process(data: string): PasteResult;
-}

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

@@ -1,20 +0,0 @@
-import type { Component } from "../tui";
-/**
- * Box component - a container that applies padding and background to all children
- */
-export declare class Box implements Component {
-    #private;
-    children: Component[];
-    constructor(paddingX?: number, paddingY?: number, bgFn?: (text: string) => string);
-    addChild(component: Component): void;
-    removeChild(component: Component): void;
-    /** Remove a child without disposing it (for detach-then-readd reuse). */
-    detachChild(component: Component): void;
-    clear(): void;
-    /** Remove all children without disposing them (for detach-then-readd reuse). */
-    detachAll(): void;
-    dispose(): void;
-    setBgFn(bgFn?: (text: string) => string): void;
-    invalidate(): void;
-    render(width: number): string[];
-}

package/dist/types/components/cancellable-loader.d.ts

@@ -1,21 +0,0 @@
-import { Loader } from "./loader";
-/**
- * Loader that can be cancelled with Escape.
- * Extends Loader with an AbortSignal for cancelling async operations.
- *
- * @example
- * const loader = new CancellableLoader(tui, cyan, dim, "Working...");
- * loader.onAbort = () => done(null);
- * doWork(loader.signal).then(done);
- */
-export declare class CancellableLoader extends Loader {
-    #private;
-    /** Called when user presses Escape */
-    onAbort?: () => void;
-    /** AbortSignal that is aborted when user presses Escape */
-    get signal(): AbortSignal;
-    /** Whether the loader was aborted */
-    get aborted(): boolean;
-    handleInput(data: string): void;
-    dispose(): void;
-}

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

@@ -1,126 +0,0 @@
-import { type AutocompleteProvider } from "../autocomplete";
-import type { SymbolTheme } from "../symbols";
-import { type Component, type Focusable } from "../tui";
-import { type SelectListTheme } from "./select-list";
-export interface EditorTheme {
-    borderColor: (str: string) => string;
-    selectList: SelectListTheme;
-    symbols: SymbolTheme;
-    editorPaddingX?: number;
-    /** Style function for inline hint/ghost text (dim text after cursor) */
-    hintStyle?: (text: string) => string;
-}
-export interface EditorTopBorder {
-    /** The status content (already styled) */
-    content: string;
-    /** Visible width of the content */
-    width: number;
-}
-export type EditorBorderStyle = "round" | "sharp";
-interface HistoryEntry {
-    prompt: string;
-}
-interface HistoryStorage {
-    add(prompt: string, cwd?: string): Promise<void>;
-    getRecent(limit: number, cwd?: string): HistoryEntry[];
-}
-/** Test-only performance counters for advisory baseline tests. */
-export declare const __editorPerfCounters: {
-    layoutTextInvocations: number;
-    layoutLogicalLinesProcessed: number;
-    visibleWidthMeasurements: number;
-    reset(): void;
-};
-export declare class Editor implements Component, Focusable {
-    #private;
-    /** Focusable interface - set by TUI when focus changes */
-    focused: boolean;
-    /** When set, replaces the normal cursor glyph at end-of-text with this ANSI-styled string. */
-    cursorOverride: string | undefined;
-    /** Display width of the cursorOverride glyph (needed because override may contain ANSI escapes). */
-    cursorOverrideWidth: number | undefined;
-    borderColor: (str: string) => string;
-    onAutocompleteUpdate?: () => void;
-    onSubmit?: (text: string) => void;
-    onAltEnter?: (text: string) => void;
-    onChange?: (text: string) => void;
-    onAutocompleteCancel?: () => void;
-    onTabDeclined?: (text: string) => void;
-    /**
-     * Called before Tab opens/applies autocomplete. Return true to consume Tab
-     * for app-level behavior (for example, queueing a draft while a turn runs).
-     */
-    onTab?: (text: string) => boolean | undefined;
-    disableSubmit: boolean;
-    constructor(theme: EditorTheme);
-    dispose(): void;
-    setAutocompleteProvider(provider: AutocompleteProvider): void;
-    getAutocompleteProvider(): AutocompleteProvider | undefined;
-    /** Whether the autocomplete dropdown is currently open. */
-    isAutocompleteOpen(): boolean;
-    /**
-     * Set custom content for the top border (e.g., status line).
-     * Pass undefined to use the default plain border.
-     */
-    setTopBorder(content: EditorTopBorder | undefined): void;
-    /**
-     * Show or hide the editor border chrome.
-     */
-    setBorderVisible(borderVisible: boolean): void;
-    setBorderStyle(borderStyle: EditorBorderStyle): void;
-    setClosedBorderBox(closedBorderBox: boolean): void;
-    setPromptGutter(promptGutter: string | undefined): void;
-    setInputPrefix(inputPrefix: string | undefined): void;
-    setPlaceholder(placeholder: string | undefined): void;
-    /**
-     * Get the available width for top border content given a total terminal width.
-     * Accounts for right gutter, border characters, and horizontal padding when visible.
-     */
-    getTopBorderAvailableWidth(terminalWidth: number): number;
-    /**
-     * Use the real terminal cursor instead of rendering a cursor glyph.
-     */
-    setUseTerminalCursor(useTerminalCursor: boolean): void;
-    getUseTerminalCursor(): boolean;
-    setMaxHeight(maxHeight: number | undefined): void;
-    setPaddingX(paddingX: number): void;
-    setRightGutterWidth(width: number): void;
-    getAutocompleteMaxVisible(): number;
-    setAutocompleteMaxVisible(maxVisible: number): void;
-    setHistoryStorage(storage: HistoryStorage): void;
-    /**
-     * Add a prompt to history for up/down arrow navigation.
-     * Called after successful submission.
-     */
-    addToHistory(text: string): void;
-    invalidate(): void;
-    render(width: number): string[];
-    handleInput(data: string): void;
-    /** Test-only seam: current wrap-cache entry count (memory-bound assertions). */
-    get wrappedLineCacheSize(): number;
-    getText(): string;
-    /**
-     * Get text with paste markers expanded to their actual content.
-     * Use this when you need the full content (e.g., for external editor).
-     */
-    getExpandedText(): string;
-    getLines(): string[];
-    getCursor(): {
-        line: number;
-        col: number;
-    };
-    moveToLineStart(): void;
-    moveToLineEnd(): void;
-    moveToMessageStart(): void;
-    moveToMessageEnd(): void;
-    /**
-     * Undo the last meaningful edit while ignoring transient text that is still present at the cursor.
-     * Used for command-like autocomplete actions whose typed trigger should not count as the edit being undone.
-     */
-    undoPastTransientText(transientText: string): void;
-    setText(text: string): void;
-    /** Insert text at the current cursor position */
-    insertText(text: string): void;
-    isShowingAutocomplete(): boolean;
-}
-export {};

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

@@ -1,18 +0,0 @@
-import { type ImageDimensions } from "../terminal-capabilities";
-import type { Component } from "../tui";
-export interface ImageTheme {
-    fallbackColor: (str: string) => string;
-}
-export interface ImageOptions {
-    maxWidthCells?: number;
-    maxHeightCells?: number;
-    filename?: string;
-    refetch?: () => string;
-}
-export declare class Image implements Component {
-    #private;
-    constructor(base64Data: string, mimeType: string, theme: ImageTheme, options?: ImageOptions, dimensions?: ImageDimensions);
-    invalidate(): void;
-    get retainedBase64DataForTest(): string | undefined;
-    render(width: number): string[];
-}

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

@@ -1,16 +0,0 @@
-import { type Component, type Focusable } from "../tui";
-/**
- * Input component - single-line text input with horizontal scrolling
- */
-export declare class Input implements Component, Focusable {
-    #private;
-    onSubmit?: (value: string) => void;
-    onEscape?: () => void;
-    /** Focusable interface - set by TUI when focus changes */
-    focused: boolean;
-    getValue(): string;
-    setValue(value: string): void;
-    handleInput(data: string): void;
-    invalidate(): void;
-    render(width: number): string[];
-}

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

@@ -1,23 +0,0 @@
-import type { TUI } from "../tui";
-import { Text } from "./text";
-export interface LoaderOptions {
-    timeDependentColor?: boolean;
-}
-/** Test-only performance counters for advisory baseline tests. */
-export declare const __loaderPerfCounters: {
-    liveIntervals: number;
-    startedIntervals: number;
-    reset(): void;
-};
-export declare class Loader extends Text {
-    #private;
-    private spinnerColorFn;
-    private messageColorFn;
-    private message;
-    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string, spinnerFrames?: string[], options?: LoaderOptions);
-    render(width: number): string[];
-    start(): void;
-    stop(): void;
-    dispose(): void;
-    setMessage(message: string): void;
-}

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

@@ -1,78 +0,0 @@
-import type { SymbolTheme } from "../symbols";
-import type { Component } from "../tui";
-/** Test-only clock seam for streaming throttle tests. */
-export declare function __setMarkdownNowForTest(now: (() => number) | undefined): void;
-/** Test/diagnostic seam: number of synchronous highlight invocations since the last reset. */
-export declare function getMarkdownHighlightCallCount(): number;
-export declare function resetMarkdownHighlightCallCount(): void;
-/** Test-only performance counters for advisory baseline tests. */
-export declare const __markdownPerfCounters: {
-    lexerInvocations: number;
-    lexedBytes: number;
-    reset(): void;
-};
-/** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
-export declare function clearRenderCache(): void;
-export declare function getRenderCacheRetainedBytes(): number;
-/**
- * Default text styling for markdown content.
- * Applied to all text unless overridden by markdown formatting.
- */
-export interface DefaultTextStyle {
-    /** Foreground color function */
-    color?: (text: string) => string;
-    /** Background color function */
-    bgColor?: (text: string) => string;
-    /** Bold text */
-    bold?: boolean;
-    /** Italic text */
-    italic?: boolean;
-    /** Strikethrough text */
-    strikethrough?: boolean;
-    /** Underline text */
-    underline?: boolean;
-}
-/**
- * Theme functions for markdown elements.
- * Each function takes text and returns styled text with ANSI codes.
- */
-export interface MarkdownTheme {
-    heading: (text: string) => string;
-    link: (text: string) => string;
-    linkUrl: (text: string) => string;
-    code: (text: string) => string;
-    codeBlock: (text: string) => string;
-    codeBlockBorder: (text: string) => string;
-    quote: (text: string) => string;
-    quoteBorder: (text: string) => string;
-    hr: (text: string) => string;
-    listBullet: (text: string) => string;
-    bold: (text: string) => string;
-    italic: (text: string) => string;
-    strikethrough: (text: string) => string;
-    underline: (text: string) => string;
-    highlightCode?: (code: string, lang?: string) => string[];
-    /**
-     * Resolve a mermaid ASCII rendering by fenced block source text.
-     * Return null to fall back to fenced code rendering.
-     */
-    resolveMermaidAscii?: (source: string) => string | null;
-    symbols: SymbolTheme;
-}
-export declare class Markdown implements Component {
-    #private;
-    constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle, codeBlockIndent?: number);
-    setOnStaleThrottle(callback: (() => void) | undefined): void;
-    setText(text: string, options?: {
-        streaming?: boolean;
-    }): void;
-    setStreaming(streaming: boolean): void;
-    dispose(): void;
-    invalidate(): void;
-    render(width: number): string[];
-}
-/**
- * Render inline markdown (bold, italic, code, links, strikethrough) to a styled string.
- * Unlike the full Markdown component, this produces a single line with no block-level elements.
- */
-export declare function renderInlineMarkdown(text: string, mdTheme: MarkdownTheme, baseColor?: (t: string) => string): string;

package/dist/types/components/select-list.d.ts

@@ -1,46 +0,0 @@
-import type { SymbolTheme } from "../symbols";
-import type { Component } from "../tui";
-export interface SelectItem {
-    value: string;
-    label: string;
-    description?: string;
-    /** Dim hint text shown inline after cursor when this item is selected */
-    hint?: string;
-}
-export interface SelectListTheme {
-    selectedPrefix: (text: string) => string;
-    selectedText: (text: string) => string;
-    description: (text: string) => string;
-    scrollInfo: (text: string) => string;
-    noMatch: (text: string) => string;
-    symbols: SymbolTheme;
-}
-export interface SelectListTruncatePrimaryContext {
-    text: string;
-    maxWidth: number;
-    columnWidth: number;
-    item: SelectItem;
-    isSelected: boolean;
-}
-export interface SelectListLayoutOptions {
-    minPrimaryColumnWidth?: number;
-    maxPrimaryColumnWidth?: number;
-    truncatePrimary?: (context: SelectListTruncatePrimaryContext) => string;
-}
-export declare class SelectList implements Component {
-    #private;
-    private readonly items;
-    private readonly maxVisible;
-    private readonly theme;
-    private readonly layout;
-    onSelect?: (item: SelectItem) => void;
-    onCancel?: () => void;
-    onSelectionChange?: (item: SelectItem) => void;
-    constructor(items: ReadonlyArray<SelectItem>, maxVisible: number, theme: SelectListTheme, layout?: SelectListLayoutOptions);
-    setFilter(filter: string): void;
-    setSelectedIndex(index: number): void;
-    invalidate(): void;
-    render(width: number): string[];
-    handleInput(keyData: string): void;
-    getSelectedItem(): SelectItem | null;
-}