@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/vue/components/TerminalProvider.d.ts

@@ -0,0 +1,218 @@
+import type { PropType } from "vue";
+import type { WidthProvider } from "../../core/buffer/width.js";
+import type { PathPickerProvider } from "../../core/path-provider-types.js";
+import type { Style } from "../../core/types.js";
+import type { TerminalEventRecord } from "../../events/recording.js";
+import type { DomRendererOptions } from "../../renderer/dom/dom-renderer.js";
+import type { ClipboardApi } from "../../runtime/index.js";
+import type { TerminalSelectionCopyPayload } from "../../selection/terminal-selection.js";
+import type { TInputPlugin } from "./input/plugins/types.js";
+import type { TuiThemeOverrides } from "../theme.js";
+import { type TerminalLinkOpenerLike } from "./link/host.js";
+import { type TerminalProviderSelectionConfig } from "./terminal-provider/selection-config.js";
+export type { TerminalProviderSelectionConfig, TerminalProviderSelectionOptions, } from "./terminal-provider/selection-config.js";
+export declare const TerminalProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    cols: {
+        type: NumberConstructor;
+        required: true;
+    };
+    rows: {
+        type: NumberConstructor;
+        required: true;
+    };
+    widthProvider: {
+        type: PropType<WidthProvider>;
+        default: string;
+    };
+    defaultStyle: {
+        type: PropType<Style>;
+        default: () => {};
+    };
+    theme: {
+        type: PropType<TuiThemeOverrides>;
+        default: undefined;
+    };
+    autoResize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minCols: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    recordEvents: {
+        type: PropType<((e: TerminalEventRecord) => void) | undefined>;
+        default: undefined;
+    };
+    inputPlugins: {
+        type: PropType<readonly TInputPlugin[]>;
+        default: () => Readonly<{
+            name: string;
+            install: (ctx: import("../index.js").TInputPluginContext) => void;
+        }>[];
+    };
+    pathPickerProvider: {
+        type: PropType<PathPickerProvider>;
+        default: undefined;
+    };
+    linkOpener: {
+        type: PropType<TerminalLinkOpenerLike>;
+        default: undefined;
+    };
+    debugIme: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    debugTrace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    domRendererOptions: {
+        type: PropType<DomRendererOptions>;
+        default: undefined;
+    };
+    clipboard: {
+        type: PropType<ClipboardApi>;
+        default: undefined;
+    };
+    selection: {
+        type: PropType<TerminalProviderSelectionConfig>;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    selectionCopy: (_payload: TerminalSelectionCopyPayload) => true;
+}, string, (import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps), Readonly<import("vue").ExtractPropTypes<{
+    cols: {
+        type: NumberConstructor;
+        required: true;
+    };
+    rows: {
+        type: NumberConstructor;
+        required: true;
+    };
+    widthProvider: {
+        type: PropType<WidthProvider>;
+        default: string;
+    };
+    defaultStyle: {
+        type: PropType<Style>;
+        default: () => {};
+    };
+    theme: {
+        type: PropType<TuiThemeOverrides>;
+        default: undefined;
+    };
+    autoResize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minCols: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    recordEvents: {
+        type: PropType<((e: TerminalEventRecord) => void) | undefined>;
+        default: undefined;
+    };
+    inputPlugins: {
+        type: PropType<readonly TInputPlugin[]>;
+        default: () => Readonly<{
+            name: string;
+            install: (ctx: import("../index.js").TInputPluginContext) => void;
+        }>[];
+    };
+    pathPickerProvider: {
+        type: PropType<PathPickerProvider>;
+        default: undefined;
+    };
+    linkOpener: {
+        type: PropType<TerminalLinkOpenerLike>;
+        default: undefined;
+    };
+    debugIme: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    debugTrace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    domRendererOptions: {
+        type: PropType<DomRendererOptions>;
+        default: undefined;
+    };
+    clipboard: {
+        type: PropType<ClipboardApi>;
+        default: undefined;
+    };
+    selection: {
+        type: PropType<TerminalProviderSelectionConfig>;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSelectionCopy?: ((_payload: Readonly<{
+        text: string;
+        rows: number;
+        chars: number;
+        ok: boolean;
+        error?: unknown;
+    }>) => any) | undefined;
+}>, {
+    widthProvider: WidthProvider;
+    debugIme: boolean;
+    clipboard: Readonly<{
+        supported: boolean;
+        readText: () => Promise<string>;
+        writeText: (text: string) => Promise<void>;
+    }>;
+    selection: TerminalProviderSelectionConfig;
+    defaultStyle: Readonly<{
+        fg?: string;
+        bg?: string;
+        bold?: boolean;
+        dim?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        inverse?: boolean;
+        href?: string;
+    }>;
+    theme: Readonly<{
+        colors?: import("../theme.js").TuiThemeColorTokens;
+        components?: import("../theme.js").TuiThemeComponentTokens;
+    }>;
+    inputPlugins: readonly Readonly<{
+        name: string;
+        install: (ctx: import("../index.js").TInputPluginContext) => void;
+    }>[];
+    pathPickerProvider: Readonly<{
+        listDir: (absDir: string) => Promise<import("../../cli.js").FsDirEntry[]>;
+        stat: (absPath: string) => Promise<import("../../cli.js").FsStat>;
+        suggest?: (info: Readonly<{
+            workspaceAbs: string;
+            input: string;
+            mode: import("../../cli.js").PathPickMode;
+            max: number;
+            showHidden?: boolean;
+            maxDepth?: number;
+            gitignore?: "blocking" | "nonBlocking";
+        }>) => Promise<import("../../cli.js").SuggestPathsResult>;
+        resolvePath?: (workspaceAbs: string, input: string) => string | Promise<string>;
+    }>;
+    linkOpener: TerminalLinkOpenerLike;
+    autoResize: boolean;
+    minCols: number;
+    minRows: number;
+    recordEvents: ((e: TerminalEventRecord) => void) | undefined;
+    debugTrace: boolean;
+    domRendererOptions: DomRendererOptions;
+}, {}>;

package/dist/vue/components/input/host.d.ts

@@ -0,0 +1,17 @@
+export type ResolveTInputPathInfo = Readonly<{
+    workspace: string;
+    input: string;
+    preserveBackslash?: boolean;
+    homeDir?: string;
+}>;
+export type TInputHostAdapter = Readonly<{
+    isTerminalLike?: boolean;
+    resolvePath?: (info: ResolveTInputPathInfo) => string;
+    pathToHref?: (pathLike: string) => string | undefined;
+    readClipboardText?: () => Promise<string>;
+    writeClipboardText?: (text: string) => Promise<boolean>;
+    showToast?: (message: string) => void;
+}>;
+export declare function resolveDefaultTInputPath(info: ResolveTInputPathInfo): string;
+export declare function fileUrlToPathLike(input: string): string | null;
+export declare function pathToTerminalFileHref(pathLike: string): string | undefined;

package/dist/vue/components/input/plugins/hostPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { TInputHostAdapter } from "../host.js";
+import type { TInputPlugin } from "./types.js";
+export declare function createTInputHostPlugin(adapterOrFactory?: TInputHostAdapter | (() => TInputHostAdapter)): TInputPlugin;
+export declare const defaultTInputHostPlugin: Readonly<{
+    name: string;
+    install: (ctx: import("./types.js").TInputPluginContext) => void;
+}>;

package/dist/vue/components/input/plugins/hostPlugin.node.d.ts

@@ -0,0 +1,15 @@
+import type { TInputHostAdapter } from "../host.js";
+export type CreateDefaultTInputHostAdapterOptions = Readonly<{
+    clipboardCommandTimeoutMs?: number;
+    clipboardTotalTimeoutMs?: number;
+    /** Max bytes for OSC52 clipboard writes. */
+    clipboardWriteMaxBytes?: number;
+    /** @deprecated Use clipboardWriteMaxBytes. */
+    clipboardMaxBytes?: number;
+    clipboardReadMaxBytes?: number;
+}>;
+export declare function createDefaultTInputHostAdapter(options?: CreateDefaultTInputHostAdapterOptions): TInputHostAdapter;
+export declare const defaultTInputHostPlugin: Readonly<{
+    name: string;
+    install: (ctx: import("./types.js").TInputPluginContext) => void;
+}>;

package/dist/vue/components/input/plugins/mentionUtils.d.ts

@@ -0,0 +1,17 @@
+import type { Style } from "../../../../core/types.js";
+export declare function isCommitMention(value: string): boolean;
+export declare function getCommitIdFromMention(value: string): string | null;
+export declare function createPasteImagePlaceholderPath(id: number): string;
+export declare function isPasteImagePlaceholderPath(absPath: string): boolean;
+export declare function basenameFromPath(path: string): string;
+export declare function getFileExtension(path: string): string;
+export declare function isImageFile(extension: string): boolean;
+export declare function isVideoFile(extension: string): boolean;
+export declare function isAudioFile(extension: string): boolean;
+export declare function isDocumentFile(extension: string): boolean;
+export declare function isCodeFile(extension: string): boolean;
+export declare function mentionLabelFromAbsPath(absPath: string, opts?: Readonly<{
+    index?: number;
+}>): string;
+export type MentionFsKind = "file" | "directory" | "other";
+export declare function mentionChipStyle(baseStyle: Style, _absPath: string, _fsKind?: MentionFsKind): Style;

package/dist/vue/components/input/plugins/nodeMentionPathProvider.d.ts

@@ -0,0 +1,2 @@
+import type { MentionPathProvider } from "./promptMentionState.js";
+export declare function createNodeMentionPathProvider(): MentionPathProvider;

package/dist/vue/components/input/plugins/promptMentionPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { MentionPathProvider, MentionSuggestionProvider } from "./promptMentionState.js";
+import type { TInputPlugin } from "./types.js";
+export type { MentionPathProvider, MentionSuggestionProvider } from "./promptMentionState.js";
+export type PromptMentionPluginOptions = Readonly<{
+    mentionSuggestionProviders?: readonly MentionSuggestionProvider[];
+    mentionPathProvider?: MentionPathProvider;
+}>;
+export declare function createPromptMentionPlugin(options?: PromptMentionPluginOptions): TInputPlugin;

package/dist/vue/components/input/plugins/promptMentionState.d.ts

@@ -0,0 +1,98 @@
+import type { ComputedRef, Ref } from "vue";
+import type { FsEntryKind } from "../../../../core/path-provider-types.js";
+import type { PathPickMode, PathSuggestion } from "../../../../core/path-suggest.js";
+import type { Terminal } from "../../../../core/types.js";
+import type { Rect } from "../../../../events/manager/types.js";
+export type PromptSuggestion = Readonly<{
+    value: string;
+    insert?: string;
+    label?: string;
+    detail?: string;
+    keywords?: readonly string[];
+    mentionValue?: string;
+    mentionBehavior?: "collect" | "inline";
+    onSelect?: (info: Readonly<{
+        value: string;
+        query: string;
+    }>) => void | boolean;
+}>;
+export type MentionSuggestionProvider = (info: Readonly<{
+    query: string;
+    tokenText: string;
+    trigger: string;
+    workspace: string;
+    maxItems: number;
+}>) => readonly PromptSuggestion[] | Promise<readonly PromptSuggestion[]>;
+export type MentionPathProvider = Readonly<{
+    stat?: (absPath: string) => FsEntryKind | null | undefined | Promise<FsEntryKind | null | undefined>;
+    suggest?: (info: Readonly<{
+        workspaceAbs: string;
+        input: string;
+        mode: PathPickMode;
+        max: number;
+        showHidden: boolean;
+        maxDepth: number;
+    }>) => readonly PathSuggestion[] | Promise<readonly PathSuggestion[]>;
+}>;
+export type PromptContext = Readonly<{
+    tokenStart: number;
+    tokenEnd: number;
+    tokenText: string;
+    query: string;
+    key: string;
+    trigger: string;
+}>;
+type PromptMatch = Readonly<{
+    item: PromptSuggestion;
+    score: number;
+    order: number;
+}>;
+export declare function fuzzyScore(query: string, candidate: string): number | null;
+export type UsePromptMentionStateOptions = Readonly<{
+    props: Readonly<{
+        promptSuggestions: readonly PromptSuggestion[];
+        promptTrigger: string;
+        promptTriggers?: readonly string[];
+        promptMaxItems: number;
+        promptAlign: "input" | "center";
+        mentionTrigger: string;
+        mentionWorkspace: string;
+        mentionMode: PathPickMode;
+        mentionShowHidden: boolean;
+        mentionSuggestions: readonly PromptSuggestion[];
+        mentionMaxItems: number;
+        mentions: readonly string[];
+        skillTrigger?: string;
+        skillSuggestions?: readonly PromptSuggestion[];
+    }>;
+    mentionSuggestionProviders?: readonly MentionSuggestionProvider[];
+    mentionPathProvider?: MentionPathProvider;
+    focused: Ref<boolean>;
+    cursor: Ref<number>;
+    getValue: () => string;
+    rawAbsRect: ComputedRef<Rect>;
+    terminal: Terminal;
+    scheduler: Readonly<{
+        invalidate: () => void;
+    }>;
+    multilineToken: string;
+    mentionToken: string;
+}>;
+export declare function usePromptMentionState(options: UsePromptMentionStateOptions): Readonly<{
+    promptActive: Ref<number>;
+    promptSuppressedKey: Ref<string | null>;
+    mentionKindByPath: Map<string, "file" | "directory" | "other">;
+    mentionKindVersion: Ref<number>;
+    promptContext: ComputedRef<PromptContext | null>;
+    mentionContext: ComputedRef<PromptContext | null>;
+    activeContext: ComputedRef<PromptContext | null>;
+    /** Full match list (not windowed). */
+    promptMatches: ComputedRef<readonly PromptMatch[]>;
+    /** Windowed list used for rendering and click mapping. */
+    promptMatchesVisible: ComputedRef<readonly PromptMatch[]>;
+    promptWindowStart: ComputedRef<number>;
+    promptActiveVisible: ComputedRef<number>;
+    promptVisible: ComputedRef<boolean>;
+    promptRect: ComputedRef<Rect>;
+}>;
+export {};

package/dist/vue/components/input/plugins/restrictText.d.ts

@@ -0,0 +1,27 @@
+import type { TInputPlugin } from "./types.js";
+export type TextRestrictionRule = Readonly<{
+    allowChars: RegExp;
+} | {
+    denyChars: RegExp;
+} | {
+    replace: Readonly<{
+        from: RegExp;
+        to: string;
+    }>;
+} | {
+    allow: RegExp;
+} | {
+    filter: (info: Readonly<{
+        text: string;
+        value: string;
+        cursor: number;
+        selection: null | Readonly<{
+            start: number;
+            end: number;
+        }>;
+    }>) => string;
+}>;
+export declare function createTextRestrictionPlugin(options: Readonly<{
+    name?: string;
+    rules: readonly TextRestrictionRule[];
+}>): TInputPlugin;

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

@@ -0,0 +1,90 @@
+import type { ComputedRef, Ref } from "vue";
+import type { PathPickMode } from "../../../../core/path-suggest.js";
+import type { TerminalRenderPlane } from "../../../../core/render-plane.js";
+import type { Style, Terminal } from "../../../../core/types.js";
+import type { Rect, TerminalKeyboardEvent } from "../../../../events/manager/types.js";
+import type { TerminalScheduler } from "../../../context.js";
+import type { TInputHostAdapter } from "../host.js";
+export type PromptSuggestion = Readonly<{
+    value: string;
+    insert?: string;
+    label?: string;
+    detail?: string;
+    keywords?: readonly string[];
+    mentionValue?: string;
+    mentionBehavior?: "collect" | "inline";
+    onSelect?: (info: Readonly<{
+        value: string;
+        query: string;
+    }>) => void | boolean;
+}>;
+export type TInputPluginContext = Readonly<{
+    getProps: () => Readonly<{
+        zIndex: number;
+        style?: Style;
+        promptSuggestions: readonly PromptSuggestion[];
+        promptTrigger: string;
+        promptTriggers?: readonly string[];
+        promptMaxItems: number;
+        promptAlign: "input" | "center";
+        promptSelectedStyle?: Style;
+        promptPopupStyle?: Style;
+        promptPopupBorderStyle?: Style;
+        promptPopupMatchStyle?: Style;
+        mentionTrigger: string;
+        mentionWorkspace: string;
+        mentionMode: PathPickMode;
+        mentionShowHidden: boolean;
+        mentionSuggestions: readonly PromptSuggestion[];
+        mentionMaxItems: number;
+        mentionChipStyle?: Style;
+        collectMentions: boolean;
+        mentions: readonly string[];
+        skillTrigger?: string;
+        skillSuggestions?: readonly PromptSuggestion[];
+    }>;
+    emit: (event: string, ...args: any[]) => void;
+    terminal: Terminal;
+    scheduler: TerminalScheduler;
+    defaultStyle: Ref<Style>;
+    render: Readonly<{
+        rootStack: any;
+        createStack: (parent: any, z: number) => any;
+        invalidatePlane: (plane: TerminalRenderPlane) => void;
+    }>;
+    visible: Ref<boolean>;
+    rawAbsRect: ComputedRef<Rect>;
+    eventZ: ComputedRef<number>;
+    focused: Ref<boolean>;
+    cursor: Ref<number>;
+    getValue: () => string;
+    insertText: (text: string) => void;
+    pushUndoSnapshot: (nextValue: string) => void;
+    applyEdit: (nextValue: string, nextCursor: number) => void;
+    registerKeydownInterceptor: (fn: (e: TerminalKeyboardEvent) => boolean) => void;
+    registerTextFilter: (fn: (info: Readonly<{
+        text: string;
+        value: string;
+        cursor: number;
+        selection: null | Readonly<{
+            start: number;
+            end: number;
+        }>;
+    }>) => string) => void;
+    registerChipStyleProvider: (provider: Readonly<{
+        getStyle: (baseStyle: Style, chip: Readonly<{
+            kind: "multiline" | "mention";
+            absPath?: string;
+        }>) => Style | null | undefined;
+        version: Ref<number>;
+    }> | null) => void;
+    registerHostAdapter: (adapter: TInputHostAdapter | null) => void;
+    resolvePath: (input: string, opts?: Readonly<{
+        preserveBackslash?: boolean;
+    }>) => string;
+    mentionToken: string;
+}>;
+export type TInputPlugin = Readonly<{
+    name: string;
+    install: (ctx: TInputPluginContext) => void;
+}>;

package/dist/vue/components/input/utils/inlineText.d.ts

@@ -0,0 +1,57 @@
+import { textCellWidth as baseTextCellWidth } from "../../../utils/text.js";
+export declare const textCellWidth: typeof baseTextCellWidth;
+export declare function padEndByCells(text: string, width: number): string;
+export declare function sliceByCellsWindow(text: string, startCell: number, width: number): string;
+export type LineInfo = Readonly<{
+    start: number;
+    end: number;
+}>;
+export type WrappedLineInfo = Readonly<{
+    start: number;
+    end: number;
+}>;
+export declare function computeLines(value: string): LineInfo[];
+export declare function countMultilineTokens(value: string, multilineToken: string, endIndex?: number): number;
+export declare function countMentionTokens(value: string, mentionToken: string, endIndex?: number): number;
+export declare function tokenIndexAt(value: string, multilineToken: string, index: number): number;
+export declare function mentionIndexAt(value: string, mentionToken: string, index: number): number;
+export declare function textCellWidthInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, start: number, end: number): number;
+export declare function wrapToLinesInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, width: number): WrappedLineInfo[];
+export declare function wrapToLinesFirstWidthInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, firstWidth: number, width: number): WrappedLineInfo[];
+export declare function indexToWrappedCellColFirstWidthInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number, firstWidth: number, width: number): {
+    line: number;
+    col: number;
+    lines: WrappedLineInfo[];
+};
+export declare function indexToLineCellColInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number): {
+    line: number;
+    col: number;
+    lines: LineInfo[];
+};
+export type InlineHit = Readonly<{
+    kind: "multiline" | "mention";
+    index: number;
+}>;
+export declare function lineCellColToIndexInline(value: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, col: number): {
+    index: number;
+    hit: InlineHit | null;
+};
+export type InlineChipRender = Readonly<{
+    startCell: number;
+    label: string;
+    kind: "multiline" | "mention";
+    index: number;
+    absPath?: string;
+}>;
+export declare function buildInlineRow(value: string, displayValue: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, rowTextW: number, offX: number): {
+    text: string;
+    chips: InlineChipRender[];
+};
+export type InlineSelectionSegment = Readonly<{
+    startCell: number;
+    text: string;
+}>;
+export declare function buildInlineSelectionSegments(value: string, displayValue: string, multilineToken: string, mentionToken: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, selection: Readonly<{
+    start: number;
+    end: number;
+}>, rowTextW: number, offX: number): InlineSelectionSegment[];

package/dist/vue/components/input/utils/inlineTextTokens.d.ts

@@ -0,0 +1,34 @@
+import type { InlineHit, LineInfo, WrappedLineInfo } from "./inlineText.js";
+import { buildInlineRow as buildInlineRowCore, buildInlineSelectionSegments as buildInlineSelectionSegmentsCore } from "./inlineText.js";
+export declare const MULTILINE_TOKEN = "\uFFFC";
+export declare const MENTION_TOKEN = "\uFFF9";
+export declare function isMultilineToken(value: string, index: number): boolean;
+export declare function isMentionToken(value: string, index: number): boolean;
+export declare function countMultilineTokens(value: string, endIndex?: number): number;
+export declare function countMentionTokens(value: string, endIndex?: number): number;
+export declare function tokenIndexAt(value: string, index: number): number;
+export declare function mentionIndexAt(value: string, index: number): number;
+export declare function wrapToLinesFirstWidthInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, firstWidth: number, width: number): WrappedLineInfo[];
+export declare function indexToWrappedCellColFirstWidthInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number, firstWidth: number, width: number): {
+    line: number;
+    col: number;
+    lines: WrappedLineInfo[];
+};
+export declare function indexToLineCellColInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, index: number): {
+    line: number;
+    col: number;
+    lines: LineInfo[];
+};
+export declare function lineCellColToIndexInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, col: number): {
+    index: number;
+    hit: InlineHit | null;
+};
+export declare function wrappedCellColToIndexInline(value: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, info: WrappedLineInfo, col: number): {
+    index: number;
+    hit: InlineHit | null;
+};
+export declare function buildInlineRow(value: string, displayValue: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, rowTextW: number, offX: number): ReturnType<typeof buildInlineRowCore>;
+export declare function buildInlineSelectionSegments(value: string, displayValue: string, multilineTexts: readonly string[] | undefined, mentions: readonly string[] | undefined, lineStart: number, lineEnd: number, selection: Readonly<{
+    start: number;
+    end: number;
+}>, rowTextW: number, offX: number): ReturnType<typeof buildInlineSelectionSegmentsCore>;

package/dist/vue/components/input/utils/primitives.d.ts

@@ -0,0 +1,3 @@
+export declare function clamp(n: number, min: number, max: number): number;
+export declare function isWhitespace(ch: string): boolean;
+export declare function isWordChar(ch: string): boolean;

package/dist/vue/components/input/utils/wordNavigation.d.ts

@@ -0,0 +1,6 @@
+export declare function findWordLeft(text: string, index: number): number;
+export declare function findWordRight(text: string, index: number): number;
+export declare function tokenRangeAt(value: string, index: number): {
+    start: number;
+    end: number;
+} | null;

package/dist/vue/components/link/host.d.ts

@@ -0,0 +1,15 @@
+import type { Ref } from "vue";
+export type TerminalLinkOpenSource = "click" | "key" | "hint";
+export type TerminalLinkOpenContext = Readonly<{
+    source: TerminalLinkOpenSource;
+    label?: string;
+    cellX?: number;
+    cellY?: number;
+}>;
+export interface TerminalLinkOpener {
+    openExternal: (href: string, context: TerminalLinkOpenContext) => boolean | Promise<boolean>;
+}
+export type TerminalLinkOpenerLike = TerminalLinkOpener | ((href: string, context: TerminalLinkOpenContext) => boolean | Promise<boolean>);
+export declare const TerminalLinkOpenerContextKey: import("vue").InjectionKey<Readonly<Ref<TerminalLinkOpener | undefined>>>;
+export declare function normalizeTerminalLinkOpener(opener: TerminalLinkOpenerLike | undefined): TerminalLinkOpener | undefined;
+export declare function createBrowserLinkOpener(): TerminalLinkOpener;

package/dist/vue/components/list/list-geometry.d.ts

@@ -0,0 +1,16 @@
+import type { Rect } from "../../../events/manager/types.js";
+export type ListClipOffsets = Readonly<{
+    x: number;
+    y: number;
+}>;
+export type ListVisibleRange = Readonly<{
+    start: number;
+    end: number;
+    h: number;
+}>;
+export declare function clipOffsets(full: Rect, clip: Rect): ListClipOffsets;
+export declare function maxScrollTop(itemsLength: number, clipY: number, clipH: number): number;
+export declare function maxScrollTopForClamp(fullH: number, clipH: number, itemsLength: number, clipY: number): number | null;
+export declare function clampScrollTop(value: number, max: number | null): number;
+export declare function visibleRange(scrollTop: number, itemsLength: number, full: Rect, clip: Rect): ListVisibleRange;
+export declare function hasPaintableViewport(visible: boolean, rect: Rect): boolean;

package/dist/vue/components/list/list-paint.d.ts

@@ -0,0 +1 @@
+export declare function formatClippedInlineCellLine(raw: string, fullWidth: number, clipX: number, width: number): string;