pi2dsh 0.2.0

package/dist/pi-tui-iHoF2tFc.d.mts

@@ -0,0 +1,1043 @@
+
+import { Marked, Token, Tokens } from "marked";
+//#region src/compat/vendor/pi-tui-utils.d.ts
+/**
+ * Get the shared grapheme segmenter instance.
+ */
+declare function getGraphemeSegmenter(): Intl.Segmenter;
+/**
+ * Get the shared word segmenter instance.
+ */
+declare function getWordSegmenter(): Intl.Segmenter;
+declare const cjkBreakRegex: RegExp;
+/**
+ * Calculate the visible width of a string in terminal columns.
+ */
+declare function visibleWidth(str: string): number;
+/** Remove ANSI, OSC, and APC control sequences while preserving visible text. */
+declare function stripTerminalSequences(str: string): string;
+interface GraphemeCellRange {
+  start: number;
+  end: number;
+}
+/** Return the terminal-cell range occupied by the grapheme at a visible column. */
+declare function getGraphemeCellRange(line: string, column: number): GraphemeCellRange | undefined;
+/** Return the OSC 8 hyperlink covering a visible terminal column. */
+declare function getOsc8LinkAtColumn(line: string, column: number): string | undefined;
+declare function normalizeTerminalOutput(str: string): string;
+/**
+ * Extract ANSI escape sequences from a string at the given position.
+ */
+declare function extractAnsiCode(str: string, pos: number): {
+  code: string;
+  length: number;
+} | null;
+/**
+ * Wrap text with ANSI codes preserved.
+ *
+ * ONLY does word wrapping - NO padding, NO background colors.
+ * Returns lines where each line is <= width visible chars.
+ * Active ANSI codes are preserved across line breaks.
+ *
+ * @param text - Text to wrap (may contain ANSI codes and newlines)
+ * @param width - Maximum visible width per line
+ * @returns Array of wrapped lines (NOT padded to width)
+ */
+declare function wrapTextWithAnsi(text: string, width: number): string[];
+declare const PUNCTUATION_REGEX: RegExp;
+/**
+ * Check if a character is whitespace.
+ */
+declare function isWhitespaceChar(char: string): boolean;
+/**
+ * Check if a character is punctuation.
+ */
+declare function isPunctuationChar(char: string): boolean;
+/**
+ * Apply background color to a line, padding to full width.
+ *
+ * @param line - Line of text (may contain ANSI codes)
+ * @param width - Total width to pad to
+ * @param bgFn - Background color function
+ * @returns Line with background applied and padded to width
+ */
+declare function applyBackgroundToLine(line: string, width: number, bgFn: (text: string) => string): string;
+/**
+ * Truncate text to fit within a maximum visible width, adding ellipsis if needed.
+ * Optionally pad with spaces to reach exactly maxWidth.
+ * Properly handles ANSI escape codes (they don't count toward width).
+ *
+ * @param text - Text to truncate (may contain ANSI codes)
+ * @param maxWidth - Maximum visible width
+ * @param ellipsis - Ellipsis string to append when truncating (default: "...")
+ * @param pad - If true, pad result with spaces to exactly maxWidth (default: false)
+ * @returns Truncated text, optionally padded to exactly maxWidth
+ */
+declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string, pad?: boolean): string;
+/**
+ * Extract a range of visible columns from a line. Handles ANSI codes and wide chars.
+ * @param strict - If true, exclude wide chars at boundary that would extend past the range
+ */
+declare function sliceByColumn(line: string, startCol: number, length: number, strict?: boolean): string;
+/** Like sliceByColumn but also returns the actual visible width of the result. */
+declare function sliceWithWidth(line: string, startCol: number, length: number, strict?: boolean): {
+  text: string;
+  width: number;
+};
+//#endregion
+//#region src/compat/vendor/pi-tui-fuzzy.d.ts
+/**
+ * Fuzzy matching utilities.
+ * Matches if all query characters appear in order (not necessarily consecutive).
+ * Lower score = better match.
+ */
+interface FuzzyMatch {
+  matches: boolean;
+  score: number;
+}
+declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
+/**
+ * Filter and sort items by fuzzy match quality (best matches first).
+ * Supports whitespace- and slash-separated tokens: all tokens must match.
+ */
+declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[];
+//#endregion
+//#region src/compat/vendor/pi-tui-keys.d.ts
+/**
+ * Keyboard input handling for terminal applications.
+ *
+ * Supports both legacy terminal sequences and Kitty keyboard protocol.
+ * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+ * Reference: https://github.com/sst/opentui/blob/7da92b4088aebfe27b9f691c04163a48821e49fd/packages/core/src/lib/parse.keypress.ts
+ *
+ * Symbol keys are also supported, however some ctrl+symbol combos
+ * overlap with ASCII codes, e.g. ctrl+[ = ESC.
+ * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/#legacy-ctrl-mapping-of-ascii-keys
+ * Those can still be * used for ctrl+shift combos
+ *
+ * API:
+ * - matchesKey(data, keyId) - Check if input matches a key identifier
+ * - parseKey(data) - Parse input and return the key identifier
+ * - Key - Helper object for creating typed key identifiers
+ * - setKittyProtocolActive(active) - Set global Kitty protocol state
+ * - isKittyProtocolActive() - Query global Kitty protocol state
+ */
+/**
+ * Set the global Kitty keyboard protocol state.
+ * Called by ProcessTerminal after detecting protocol support.
+ */
+declare function setKittyProtocolActive(active: boolean): void;
+/**
+ * Query whether Kitty keyboard protocol is currently active.
+ */
+declare function isKittyProtocolActive(): boolean;
+type Letter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type SymbolKey = "`" | "-" | "=" | "[" | "]" | "\\" | ";" | "'" | "," | "." | "/" | "!" | "@" | "#" | "$" | "%" | "^" | "&" | "*" | "(" | ")" | "_" | "+" | "|" | "~" | "{" | "}" | ":" | "<" | ">" | "?";
+type SpecialKey = "escape" | "esc" | "enter" | "return" | "tab" | "space" | "backspace" | "delete" | "insert" | "clear" | "home" | "end" | "pageUp" | "pageDown" | "up" | "down" | "left" | "right" | "f1" | "f2" | "f3" | "f4" | "f5" | "f6" | "f7" | "f8" | "f9" | "f10" | "f11" | "f12";
+type BaseKey = Letter | Digit | SymbolKey | SpecialKey;
+type ModifierName = "ctrl" | "shift" | "alt" | "super";
+type ModifiedKeyId<Key extends string, RemainingModifiers extends ModifierName = ModifierName> = { [M in RemainingModifiers]: `${M}+${Key}` | `${M}+${ModifiedKeyId<Key, Exclude<RemainingModifiers, M>>}`; }[RemainingModifiers];
+/**
+ * Union type of all valid key identifiers.
+ * Provides autocomplete and catches typos at compile time.
+ */
+type KeyId = BaseKey | ModifiedKeyId<BaseKey>;
+/**
+ * Helper object for creating typed key identifiers with autocomplete.
+ *
+ * Usage:
+ * - Key.escape, Key.enter, Key.tab, etc. for special keys
+ * - Key.backtick, Key.comma, Key.period, etc. for symbol keys
+ * - Key.ctrl("c"), Key.alt("x"), Key.super("k") for single modifiers
+ * - Key.ctrlShift("p"), Key.ctrlAlt("x"), Key.ctrlSuper("k") for combined modifiers
+ */
+declare const Key: {
+  readonly escape: "escape";
+  readonly esc: "esc";
+  readonly enter: "enter";
+  readonly return: "return";
+  readonly tab: "tab";
+  readonly space: "space";
+  readonly backspace: "backspace";
+  readonly delete: "delete";
+  readonly insert: "insert";
+  readonly clear: "clear";
+  readonly home: "home";
+  readonly end: "end";
+  readonly pageUp: "pageUp";
+  readonly pageDown: "pageDown";
+  readonly up: "up";
+  readonly down: "down";
+  readonly left: "left";
+  readonly right: "right";
+  readonly f1: "f1";
+  readonly f2: "f2";
+  readonly f3: "f3";
+  readonly f4: "f4";
+  readonly f5: "f5";
+  readonly f6: "f6";
+  readonly f7: "f7";
+  readonly f8: "f8";
+  readonly f9: "f9";
+  readonly f10: "f10";
+  readonly f11: "f11";
+  readonly f12: "f12";
+  readonly backtick: "`";
+  readonly hyphen: "-";
+  readonly equals: "=";
+  readonly leftbracket: "[";
+  readonly rightbracket: "]";
+  readonly backslash: "\\";
+  readonly semicolon: ";";
+  readonly quote: "'";
+  readonly comma: ",";
+  readonly period: ".";
+  readonly slash: "/";
+  readonly exclamation: "!";
+  readonly at: "@";
+  readonly hash: "#";
+  readonly dollar: "$";
+  readonly percent: "%";
+  readonly caret: "^";
+  readonly ampersand: "&";
+  readonly asterisk: "*";
+  readonly leftparen: "(";
+  readonly rightparen: ")";
+  readonly underscore: "_";
+  readonly plus: "+";
+  readonly pipe: "|";
+  readonly tilde: "~";
+  readonly leftbrace: "{";
+  readonly rightbrace: "}";
+  readonly colon: ":";
+  readonly lessthan: "<";
+  readonly greaterthan: ">";
+  readonly question: "?";
+  readonly ctrl: <K extends BaseKey>(key: K) => `ctrl+${K}`;
+  readonly shift: <K extends BaseKey>(key: K) => `shift+${K}`;
+  readonly alt: <K extends BaseKey>(key: K) => `alt+${K}`;
+  readonly super: <K extends BaseKey>(key: K) => `super+${K}`;
+  readonly ctrlShift: <K extends BaseKey>(key: K) => `ctrl+shift+${K}`;
+  readonly shiftCtrl: <K extends BaseKey>(key: K) => `shift+ctrl+${K}`;
+  readonly ctrlAlt: <K extends BaseKey>(key: K) => `ctrl+alt+${K}`;
+  readonly altCtrl: <K extends BaseKey>(key: K) => `alt+ctrl+${K}`;
+  readonly shiftAlt: <K extends BaseKey>(key: K) => `shift+alt+${K}`;
+  readonly altShift: <K extends BaseKey>(key: K) => `alt+shift+${K}`;
+  readonly ctrlSuper: <K extends BaseKey>(key: K) => `ctrl+super+${K}`;
+  readonly superCtrl: <K extends BaseKey>(key: K) => `super+ctrl+${K}`;
+  readonly shiftSuper: <K extends BaseKey>(key: K) => `shift+super+${K}`;
+  readonly superShift: <K extends BaseKey>(key: K) => `super+shift+${K}`;
+  readonly altSuper: <K extends BaseKey>(key: K) => `alt+super+${K}`;
+  readonly superAlt: <K extends BaseKey>(key: K) => `super+alt+${K}`;
+  readonly ctrlShiftAlt: <K extends BaseKey>(key: K) => `ctrl+shift+alt+${K}`;
+  readonly ctrlShiftSuper: <K extends BaseKey>(key: K) => `ctrl+shift+super+${K}`;
+};
+/**
+ * Event types from Kitty keyboard protocol (flag 2)
+ * 1 = key press, 2 = key repeat, 3 = key release
+ */
+type KeyEventType = "press" | "repeat" | "release";
+/**
+ * Check if the last parsed key event was a key release.
+ * Only meaningful when Kitty keyboard protocol with flag 2 is active.
+ */
+declare function isKeyRelease(data: string): boolean;
+/**
+ * Check if the last parsed key event was a key repeat.
+ * Only meaningful when Kitty keyboard protocol with flag 2 is active.
+ */
+declare function isKeyRepeat(data: string): boolean;
+/**
+ * Match input data against a key identifier string.
+ *
+ * Supported key identifiers:
+ * - Single keys: "escape", "tab", "enter", "backspace", "delete", "home", "end", "space"
+ * - Arrow keys: "up", "down", "left", "right"
+ * - Ctrl combinations: "ctrl+c", "ctrl+z", etc.
+ * - Shift combinations: "shift+tab", "shift+enter"
+ * - Alt combinations: "alt+enter", "alt+backspace"
+ * - Super combinations: "super+k", "super+enter"
+ * - Combined modifiers: "shift+ctrl+p", "ctrl+alt+x", "ctrl+super+k"
+ *
+ * Use the Key helper for autocomplete: Key.ctrl("c"), Key.escape, Key.ctrlShift("p"), Key.super("k")
+ *
+ * @param data - Raw input data from terminal
+ * @param keyId - Key identifier (e.g., "ctrl+c", "escape", Key.ctrl("c"))
+ */
+declare function matchesKey(data: string, keyId: KeyId): boolean;
+declare function parseKey(data: string): string | undefined;
+/**
+ * Decode a Kitty CSI-u sequence into a printable character, if applicable.
+ *
+ * When Kitty keyboard protocol flag 1 (disambiguate) is active, terminals send
+ * CSI-u sequences for all keys, including plain printable characters. This
+ * function extracts the printable character from such sequences.
+ *
+ * Only accepts plain or Shift-modified keys. Rejects Ctrl, Alt, and unsupported
+ * modifier combinations (those are handled by keybinding matching instead).
+ * Prefers the shifted keycode when Shift is held and a shifted key is reported.
+ *
+ * @param data - Raw input data from terminal
+ * @returns The printable character, or undefined if not a printable CSI-u sequence
+ */
+declare function decodeKittyPrintable(data: string): string | undefined;
+//#endregion
+//#region src/compat/vendor/pi-tui-terminal-colors.d.ts
+interface RgbColor {
+  r: number;
+  g: number;
+  b: number;
+}
+type TerminalColorScheme = "dark" | "light";
+declare function parseOsc11BackgroundColor(data: string): RgbColor | undefined;
+declare function parseTerminalColorSchemeReport(data: string): TerminalColorScheme | undefined;
+//#endregion
+//#region src/compat/vendor/pi-tui-keybindings.d.ts
+/**
+ * Global keybinding registry.
+ * Downstream packages can add keybindings via declaration merging.
+ */
+interface Keybindings {
+  "tui.editor.cursorUp": true;
+  "tui.editor.cursorDown": true;
+  "tui.editor.historyPrevious": true;
+  "tui.editor.historyNext": true;
+  "tui.editor.cursorLeft": true;
+  "tui.editor.cursorRight": true;
+  "tui.editor.cursorWordLeft": true;
+  "tui.editor.cursorWordRight": true;
+  "tui.editor.cursorLineStart": true;
+  "tui.editor.cursorLineEnd": true;
+  "tui.editor.jumpForward": true;
+  "tui.editor.jumpBackward": true;
+  "tui.editor.pageUp": true;
+  "tui.editor.pageDown": true;
+  "tui.editor.deleteCharBackward": true;
+  "tui.editor.deleteCharForward": true;
+  "tui.editor.deleteWordBackward": true;
+  "tui.editor.deleteWordForward": true;
+  "tui.editor.deleteToLineStart": true;
+  "tui.editor.deleteToLineEnd": true;
+  "tui.editor.yank": true;
+  "tui.editor.yankPop": true;
+  "tui.editor.undo": true;
+  "tui.input.newLine": true;
+  "tui.input.submit": true;
+  "tui.input.tab": true;
+  "tui.input.copy": true;
+  "tui.select.up": true;
+  "tui.select.down": true;
+  "tui.select.pageUp": true;
+  "tui.select.pageDown": true;
+  "tui.select.confirm": true;
+  "tui.select.cancel": true;
+  "tui.altScreen.pageUp": true;
+  "tui.altScreen.pageDown": true;
+  "tui.altScreen.halfPageUp": true;
+  "tui.altScreen.halfPageDown": true;
+  "tui.altScreen.lineUp": true;
+  "tui.altScreen.lineDown": true;
+  "tui.altScreen.previousPrompt": true;
+  "tui.altScreen.nextPrompt": true;
+  "tui.altScreen.search": true;
+  "tui.altScreen.searchNext": true;
+  "tui.altScreen.searchPrevious": true;
+  "tui.altScreen.searchClose": true;
+  "tui.altScreen.top": true;
+  "tui.altScreen.bottom": true;
+}
+type Keybinding = keyof Keybindings;
+interface KeybindingDefinition {
+  defaultKeys: KeyId | KeyId[];
+  description?: string;
+}
+type KeybindingDefinitions = Record<string, KeybindingDefinition>;
+type KeybindingsConfig = Record<string, KeyId | KeyId[] | undefined>;
+declare const TUI_KEYBINDINGS: {
+  readonly "tui.editor.cursorUp": {
+    readonly defaultKeys: "up";
+    readonly description: "Move cursor up";
+  };
+  readonly "tui.editor.cursorDown": {
+    readonly defaultKeys: "down";
+    readonly description: "Move cursor down";
+  };
+  readonly "tui.editor.historyPrevious": {
+    readonly defaultKeys: [];
+    readonly description: "Select previous prompt history entry";
+  };
+  readonly "tui.editor.historyNext": {
+    readonly defaultKeys: [];
+    readonly description: "Select next prompt history entry";
+  };
+  readonly "tui.editor.cursorLeft": {
+    readonly defaultKeys: ["left", "ctrl+b"];
+    readonly description: "Move cursor left";
+  };
+  readonly "tui.editor.cursorRight": {
+    readonly defaultKeys: ["right", "ctrl+f"];
+    readonly description: "Move cursor right";
+  };
+  readonly "tui.editor.cursorWordLeft": {
+    readonly defaultKeys: ["alt+left", "ctrl+left", "alt+b"];
+    readonly description: "Move cursor word left";
+  };
+  readonly "tui.editor.cursorWordRight": {
+    readonly defaultKeys: ["alt+right", "ctrl+right", "alt+f"];
+    readonly description: "Move cursor word right";
+  };
+  readonly "tui.editor.cursorLineStart": {
+    readonly defaultKeys: ["home", "ctrl+home", "ctrl+a"];
+    readonly description: "Move to line start";
+  };
+  readonly "tui.editor.cursorLineEnd": {
+    readonly defaultKeys: ["end", "ctrl+end", "ctrl+e"];
+    readonly description: "Move to line end";
+  };
+  readonly "tui.editor.jumpForward": {
+    readonly defaultKeys: "ctrl+]";
+    readonly description: "Jump forward to character";
+  };
+  readonly "tui.editor.jumpBackward": {
+    readonly defaultKeys: "ctrl+alt+]";
+    readonly description: "Jump backward to character";
+  };
+  readonly "tui.editor.pageUp": {
+    readonly defaultKeys: ["pageUp", "ctrl+pageUp"];
+    readonly description: "Page up";
+  };
+  readonly "tui.editor.pageDown": {
+    readonly defaultKeys: ["pageDown", "ctrl+pageDown"];
+    readonly description: "Page down";
+  };
+  readonly "tui.editor.deleteCharBackward": {
+    readonly defaultKeys: "backspace";
+    readonly description: "Delete character backward";
+  };
+  readonly "tui.editor.deleteCharForward": {
+    readonly defaultKeys: ["delete", "ctrl+d"];
+    readonly description: "Delete character forward";
+  };
+  readonly "tui.editor.deleteWordBackward": {
+    readonly defaultKeys: ["ctrl+w", "alt+backspace"];
+    readonly description: "Delete word backward";
+  };
+  readonly "tui.editor.deleteWordForward": {
+    readonly defaultKeys: ["alt+d", "alt+delete"];
+    readonly description: "Delete word forward";
+  };
+  readonly "tui.editor.deleteToLineStart": {
+    readonly defaultKeys: "ctrl+u";
+    readonly description: "Delete to line start";
+  };
+  readonly "tui.editor.deleteToLineEnd": {
+    readonly defaultKeys: "ctrl+k";
+    readonly description: "Delete to line end";
+  };
+  readonly "tui.editor.yank": {
+    readonly defaultKeys: "ctrl+y";
+    readonly description: "Yank";
+  };
+  readonly "tui.editor.yankPop": {
+    readonly defaultKeys: "alt+y";
+    readonly description: "Yank pop";
+  };
+  readonly "tui.editor.undo": {
+    readonly defaultKeys: "ctrl+-";
+    readonly description: "Undo";
+  };
+  readonly "tui.input.newLine": {
+    readonly defaultKeys: ["shift+enter", "ctrl+j"];
+    readonly description: "Insert newline";
+  };
+  readonly "tui.input.submit": {
+    readonly defaultKeys: "enter";
+    readonly description: "Submit input";
+  };
+  readonly "tui.input.tab": {
+    readonly defaultKeys: "tab";
+    readonly description: "Tab / autocomplete";
+  };
+  readonly "tui.input.copy": {
+    readonly defaultKeys: "ctrl+c";
+    readonly description: "Copy selection";
+  };
+  readonly "tui.select.up": {
+    readonly defaultKeys: "up";
+    readonly description: "Move selection up";
+  };
+  readonly "tui.select.down": {
+    readonly defaultKeys: "down";
+    readonly description: "Move selection down";
+  };
+  readonly "tui.select.pageUp": {
+    readonly defaultKeys: "pageUp";
+    readonly description: "Selection page up";
+  };
+  readonly "tui.select.pageDown": {
+    readonly defaultKeys: "pageDown";
+    readonly description: "Selection page down";
+  };
+  readonly "tui.select.confirm": {
+    readonly defaultKeys: "enter";
+    readonly description: "Confirm selection";
+  };
+  readonly "tui.select.cancel": {
+    readonly defaultKeys: ["escape", "ctrl+c"];
+    readonly description: "Cancel selection";
+  };
+  readonly "tui.altScreen.pageUp": {
+    readonly defaultKeys: "pageUp";
+    readonly description: "Scroll viewport up one page";
+  };
+  readonly "tui.altScreen.pageDown": {
+    readonly defaultKeys: "pageDown";
+    readonly description: "Scroll viewport down one page";
+  };
+  readonly "tui.altScreen.halfPageUp": {
+    readonly defaultKeys: [];
+    readonly description: "Scroll viewport up half a page";
+  };
+  readonly "tui.altScreen.halfPageDown": {
+    readonly defaultKeys: [];
+    readonly description: "Scroll viewport down half a page";
+  };
+  readonly "tui.altScreen.lineUp": {
+    readonly defaultKeys: [];
+    readonly description: "Scroll viewport up one line";
+  };
+  readonly "tui.altScreen.lineDown": {
+    readonly defaultKeys: [];
+    readonly description: "Scroll viewport down one line";
+  };
+  readonly "tui.altScreen.previousPrompt": {
+    readonly defaultKeys: "ctrl+shift+up";
+    readonly description: "Jump to previous semantic prompt";
+  };
+  readonly "tui.altScreen.nextPrompt": {
+    readonly defaultKeys: "ctrl+shift+down";
+    readonly description: "Jump to next semantic prompt";
+  };
+  readonly "tui.altScreen.search": {
+    readonly defaultKeys: "ctrl+shift+f";
+    readonly description: "Search the primary scroll view";
+  };
+  readonly "tui.altScreen.searchNext": {
+    readonly defaultKeys: ["enter", "ctrl+g"];
+    readonly description: "Select the next search match";
+  };
+  readonly "tui.altScreen.searchPrevious": {
+    readonly defaultKeys: ["shift+enter", "ctrl+shift+g"];
+    readonly description: "Select the previous search match";
+  };
+  readonly "tui.altScreen.searchClose": {
+    readonly defaultKeys: "escape";
+    readonly description: "Close transcript search";
+  };
+  readonly "tui.altScreen.top": {
+    readonly defaultKeys: "home";
+    readonly description: "Scroll viewport to top";
+  };
+  readonly "tui.altScreen.bottom": {
+    readonly defaultKeys: "end";
+    readonly description: "Scroll viewport to bottom";
+  };
+};
+interface KeybindingConflict {
+  key: KeyId;
+  keybindings: string[];
+}
+declare class KeybindingsManager {
+  private definitions;
+  private userBindings;
+  private keysById;
+  private conflicts;
+  constructor(definitions: KeybindingDefinitions, userBindings?: KeybindingsConfig);
+  private rebuild;
+  matches(data: string, keybinding: Keybinding): boolean;
+  getKeys(keybinding: Keybinding): KeyId[];
+  getDefinition(keybinding: Keybinding): KeybindingDefinition;
+  getConflicts(): KeybindingConflict[];
+  setUserBindings(userBindings: KeybindingsConfig): void;
+  getUserBindings(): KeybindingsConfig;
+  getResolvedBindings(): KeybindingsConfig;
+}
+declare function setKeybindings(keybindings: KeybindingsManager): void;
+declare function getKeybindings(): KeybindingsManager;
+//#endregion
+//#region src/compat/vendor/pi-tui-latex.d.ts
+interface RenderLatexOptions {
+  /** Stack fractions and operator limits vertically for display math (default: false). */
+  display?: boolean;
+}
+/**
+ * Render a basic LaTeX math expression as terminal-friendly Unicode text.
+ * Returns undefined when the expression contains unsupported or malformed syntax.
+ */
+declare function renderLatex(source: string, options?: RenderLatexOptions): string | undefined;
+//#endregion
+//#region src/compat/vendor/pi-tui-terminal-image.d.ts
+type ImageProtocol = "kitty" | "iterm2" | null;
+interface TerminalCapabilities {
+  images: ImageProtocol;
+  trueColor: boolean;
+  hyperlinks: boolean;
+}
+interface CellDimensions {
+  widthPx: number;
+  heightPx: number;
+}
+interface ImageDimensions {
+  widthPx: number;
+  heightPx: number;
+}
+declare function getCellDimensions(): CellDimensions;
+declare function setCellDimensions(dims: CellDimensions): void;
+declare function detectCapabilities(tmuxForwardsHyperlink?: () => boolean): TerminalCapabilities;
+declare function getCapabilities(): TerminalCapabilities;
+declare function resetCapabilitiesCache(): void;
+/** Override the cached capabilities. Useful in tests to exercise both code paths. */
+declare function setCapabilities(caps: TerminalCapabilities): void;
+/**
+ * Generate a random image ID for Kitty graphics protocol.
+ * Uses random IDs to avoid collisions between different module instances
+ * (e.g., main app vs extensions).
+ */
+declare function allocateImageId(): number;
+declare function encodeKitty(base64Data: string, options?: {
+  columns?: number;
+  rows?: number;
+  imageId?: number;
+  /** Whether Kitty should apply its default cursor movement after placement. Default: true. */
+  moveCursor?: boolean;
+}): string;
+/**
+ * Delete a Kitty graphics image by ID.
+ * Uses uppercase 'I' to also free the image data.
+ */
+declare function deleteKittyImage(imageId: number): string;
+/**
+ * Delete all visible Kitty graphics images.
+ * Uses uppercase 'A' to also free the image data.
+ */
+declare function deleteAllKittyImages(): string;
+declare function encodeITerm2(base64Data: string, options?: {
+  width?: number | string;
+  height?: number | string;
+  name?: string;
+  preserveAspectRatio?: boolean;
+  inline?: boolean;
+}): string;
+declare function calculateImageRows(imageDimensions: ImageDimensions, targetWidthCells: number, cellDimensions?: CellDimensions): number;
+declare function getPngDimensions(base64Data: string): ImageDimensions | null;
+declare function getJpegDimensions(base64Data: string): ImageDimensions | null;
+declare function getGifDimensions(base64Data: string): ImageDimensions | null;
+declare function getWebpDimensions(base64Data: string): ImageDimensions | null;
+declare function getImageDimensions(base64Data: string, mimeType: string): ImageDimensions | null;
+/**
+ * Wrap text in an OSC 8 hyperlink sequence.
+ * The text is rendered as a clickable hyperlink in terminals that support OSC 8
+ * (Ghostty, Kitty, WezTerm, iTerm2, VSCode, and others).
+ * In terminals that do not support OSC 8, the escape sequences are ignored
+ * and only the plain text is displayed.
+ *
+ * @param text - The visible text to display
+ * @param url - The URL to link to
+ */
+declare function hyperlink(text: string, url: string): string;
+/**
+ * Text fallback when the terminal cannot render inline images.
+ * Absolute paths are shown shortened (~/...) and, when OSC 8 hyperlinks are
+ * available, linked to file:// so the full path remains openable.
+ */
+declare function imageFallback(mimeType: string, dimensions?: ImageDimensions, filename?: string): string;
+//#endregion
+//#region src/compat/vendor/pi-tui-autocomplete.d.ts
+interface AutocompleteItem {
+  value: string;
+  label: string;
+  description?: string;
+}
+type Awaitable<T> = T | Promise<T>;
+interface SlashCommand {
+  name: string;
+  description?: string;
+  argumentHint?: string;
+  getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
+}
+interface AutocompleteSuggestions {
+  items: AutocompleteItem[];
+  prefix: string;
+}
+interface AutocompleteProvider {
+  /** Characters that should naturally trigger this provider at token boundaries. */
+  triggerCharacters?: string[];
+  getSuggestions(lines: string[], cursorLine: number, cursorCol: number, options: {
+    signal: AbortSignal;
+    force?: boolean;
+  }): Promise<AutocompleteSuggestions | null>;
+  applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+  };
+  shouldTriggerFileCompletion?(lines: string[], cursorLine: number, cursorCol: number): boolean;
+}
+declare class CombinedAutocompleteProvider implements AutocompleteProvider {
+  private commands;
+  private basePath;
+  private fdPath;
+  constructor(commands: (SlashCommand | AutocompleteItem)[] | undefined, basePath: string, fdPath?: string | null);
+  getSuggestions(lines: string[], cursorLine: number, cursorCol: number, options: {
+    signal: AbortSignal;
+    force?: boolean;
+  }): Promise<AutocompleteSuggestions | null>;
+  applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+  };
+  private extractAtPrefix;
+  private extractPathPrefix;
+  private expandHomePath;
+  private resolveScopedFuzzyQuery;
+  private scopedPathForDisplay;
+  private getFileSuggestions;
+  private scoreEntry;
+  private getFuzzyFileSuggestions;
+  shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+}
+//#endregion
+//#region src/compat/pi-tui.d.ts
+declare const CURSOR_MARKER = "_pi:c";
+interface Component {
+  render(width: number): string[];
+  invalidate(): void;
+  handleInput?(data: string): void;
+  wantsKeyRelease?: boolean;
+}
+interface Focusable {
+  focused: boolean;
+}
+declare function isFocusable(value: unknown): value is Focusable;
+declare class Container implements Component {
+  children: Component[];
+  addChild(child: Component): void;
+  removeChild(child: Component): void;
+  clear(): void;
+  invalidate(): void;
+  render(width: number): string[];
+}
+declare class Text implements Component {
+  text: string;
+  paddingX: number;
+  paddingY: number;
+  private customBgFn;
+  constructor(text?: string, paddingX?: number, paddingY?: number, customBgFn?: (text: string) => string);
+  setText(text: string): void;
+  setCustomBgFn(customBgFn?: (text: string) => string): void;
+  invalidate(): void;
+  render(width: number): string[];
+}
+declare class TruncatedText implements Component {
+  text: string;
+  paddingX: number;
+  paddingY: number;
+  constructor(text: string, paddingX?: number, paddingY?: number);
+  invalidate(): void;
+  render(width: number): string[];
+}
+declare class Spacer implements Component {
+  private lines;
+  constructor(lines?: number);
+  setLines(lines: number): void;
+  invalidate(): void;
+  render(_width: number): string[];
+}
+declare class Box implements Component {
+  paddingX: number;
+  paddingY: number;
+  private children;
+  private bgFn;
+  constructor(paddingX?: number, paddingY?: number, bgFn?: (text: string) => string);
+  addChild(component: Component): void;
+  removeChild(component: Component): void;
+  clear(): void;
+  setBgFn(bgFn?: (text: string) => string): void;
+  invalidate(): void;
+  render(width: number): string[];
+}
+interface MarkdownTheme {
+  [key: string]: unknown;
+}
+interface MarkdownOptions {
+  [key: string]: unknown;
+}
+type DefaultTextStyle = (text: string) => string;
+declare class Markdown implements Component {
+  text: string;
+  paddingX: number;
+  paddingY: number;
+  private theme?;
+  private options?;
+  constructor(text?: string, paddingX?: number, paddingY?: number, theme?: MarkdownTheme | undefined, options?: MarkdownOptions | undefined);
+  setText(text: string): void;
+  invalidate(): void;
+  render(width: number): string[];
+}
+interface SelectItem {
+  value: string;
+  label: string;
+  description?: string;
+}
+interface SelectListTheme {
+  selectedPrefix?: unknown;
+  selectedText?: unknown;
+  description?: unknown;
+  scrollInfo?: unknown;
+  noMatch?: unknown;
+  [key: string]: unknown;
+}
+interface SelectListLayoutOptions {
+  minPrimaryColumnWidth?: number;
+  maxPrimaryColumnWidth?: number;
+  truncatePrimary?: unknown;
+}
+interface SelectListTruncatePrimaryContext {
+  [key: string]: unknown;
+}
+declare class SelectList implements Component {
+  private items;
+  private maxVisible;
+  private theme;
+  private layout;
+  onSelect?: (item: SelectItem) => void;
+  onCancel?: () => void;
+  onSelectionChange?: (item: SelectItem) => void;
+  private filtered;
+  private selectedIndex;
+  constructor(items: SelectItem[], maxVisible: number, theme: SelectListTheme, layout?: SelectListLayoutOptions);
+  setFilter(filter: string): void;
+  setSelectedIndex(index: number): void;
+  getSelectedItem(): SelectItem | null;
+  invalidate(): void;
+  handleInput(_keyData: string): void;
+  render(width: number): string[];
+}
+interface SettingItem {
+  id: string;
+  label: string;
+  description?: string;
+  currentValue: string;
+  values?: string[];
+  submenu?: (currentValue: string, done: (selectedValue?: string) => void) => Component;
+}
+interface SettingsListTheme {
+  label?: unknown;
+  value?: unknown;
+  description?: unknown;
+  cursor?: unknown;
+  hint?: unknown;
+  [key: string]: unknown;
+}
+interface SettingsListOptions {
+  enableSearch?: boolean;
+}
+declare class SettingsList implements Component {
+  private items;
+  private maxVisible;
+  private theme;
+  private onChange;
+  private onCancel;
+  private options;
+  constructor(items: SettingItem[], maxVisible: number, theme: SettingsListTheme, onChange: (id: string, newValue: string) => void, onCancel: () => void, options?: SettingsListOptions);
+  updateValue(id: string, newValue: string): void;
+  invalidate(): void;
+  handleInput(_data: string): void;
+  render(width: number): string[];
+}
+declare class Input implements Component, Focusable {
+  focused: boolean;
+  onSubmit?: (value: string) => void;
+  onEscape?: () => void;
+  private value;
+  getValue(): string;
+  setValue(value: string): void;
+  handleInput(data: string): void;
+  invalidate(): void;
+  render(width: number): string[];
+}
+interface EditorTheme {
+  borderColor?: (s: string) => string;
+  selectList?: SelectListTheme;
+  [key: string]: unknown;
+}
+interface EditorOptions {
+  paddingX?: number;
+  autocompleteMaxVisible?: number;
+}
+interface EditorComponent {
+  getText(): string;
+  setText(text: string): void;
+  handleInput(data: string): void;
+  onSubmit?: (text: string) => void;
+  onChange?: (text: string) => void;
+  addToHistory?(text: string): void;
+  insertTextAtCursor?(text: string): void;
+  getExpandedText?(): string;
+  setAutocompleteProvider?(provider: AutocompleteProvider): void;
+}
+declare class Editor implements Component, Focusable, EditorComponent {
+  private tui?;
+  private theme;
+  private options;
+  focused: boolean;
+  borderColor: (str: string) => string;
+  onSubmit?: (text: string) => void;
+  onChange?: (text: string) => void;
+  disableSubmit: boolean;
+  private text;
+  private history;
+  private autocompleteProvider?;
+  constructor(tui?: unknown | undefined, theme?: EditorTheme, options?: EditorOptions);
+  getText(): string;
+  setText(text: string): void;
+  getExpandedText(): string;
+  insertTextAtCursor(text: string): void;
+  addToHistory(text: string): void;
+  setAutocompleteProvider(provider: AutocompleteProvider): void;
+  getPaddingX(): number;
+  setPaddingX(padding: number): void;
+  getAutocompleteMaxVisible(): number;
+  setAutocompleteMaxVisible(maxVisible: number): void;
+  handleInput(data: string): void;
+  invalidate(): void;
+  render(width: number): string[];
+}
+interface StackEntryOptions {
+  [key: string]: unknown;
+}
+type StackChild = Component | {
+  component: Component;
+  options?: StackEntryOptions;
+};
+interface StackEntry {
+  component: Component;
+  options?: StackEntryOptions;
+}
+interface StackOptions {
+  [key: string]: unknown;
+}
+declare class Stack extends Container {
+  protected options: StackOptions;
+  constructor(children?: StackChild[], options?: StackOptions);
+}
+declare class VStack extends Stack {}
+declare class HStack extends Stack {
+  render(width: number): string[];
+}
+interface LoaderIndicatorOptions {
+  frames?: string[];
+  intervalMs?: number;
+}
+declare class Loader extends Text {
+  constructor(message?: string, indicator?: LoaderIndicatorOptions);
+  start(): void;
+  stop(): void;
+  setMessage(message: string): void;
+  setIndicator(_indicator?: LoaderIndicatorOptions): void;
+}
+declare class CancellableLoader extends Loader {
+  onCancel?: () => void;
+  handleInput(data: string): void;
+  dispose(): void;
+}
+interface ImageOptions {
+  [key: string]: unknown;
+}
+interface ImageTheme {
+  [key: string]: unknown;
+}
+declare class Image implements Component {
+  private base64Data;
+  private mimeType;
+  private options;
+  constructor(base64Data?: string, mimeType?: string, options?: ImageOptions);
+  getImageId(): number | undefined;
+  invalidate(): void;
+  render(width: number): string[];
+}
+interface ScrollViewScrollbar {
+  [key: string]: unknown;
+}
+interface ScrollViewOptions {
+  [key: string]: unknown;
+}
+interface ScrollViewScrollToOptions {
+  [key: string]: unknown;
+}
+declare class ScrollView extends Container {
+  private options;
+  private scrollTop;
+  constructor(component: Component, options?: ScrollViewOptions);
+  setScrollbar(_scrollbar: ScrollViewScrollbar): void;
+  getContentWidth(width: number): number;
+  setScrollbarActive(_active: boolean): void;
+  scrollTo(scrollTop: number, _options?: ScrollViewScrollToOptions): void;
+  scrollBy(lines: number): number;
+  scrollToStart(): void;
+  scrollToEnd(): void;
+  updateLayout(_contentHeight: number, _viewportHeight: number, _requestRender: () => void): void;
+}
+interface OverlayMargin {
+  top?: number;
+  right?: number;
+  bottom?: number;
+  left?: number;
+}
+type SizeValue = number | `${number}%`;
+interface OverlayAnchor {
+  [key: string]: unknown;
+}
+interface OverlayOptions {
+  width?: SizeValue;
+  maxHeight?: SizeValue;
+  anchor?: OverlayAnchor;
+  margin?: OverlayMargin;
+  [key: string]: unknown;
+}
+interface OverlayUnfocusOptions {
+  [key: string]: unknown;
+}
+interface OverlayHandle {
+  close(): void;
+  [key: string]: unknown;
+}
+type TuiMode = 'regular' | 'fullscreen';
+interface TuiStopOptions {
+  preserveScreen?: boolean;
+}
+type TuiInputListenerResult = {
+  consume?: boolean;
+  data?: string;
+} | undefined;
+type TuiInputListener = (data: string) => TuiInputListenerResult;
+interface TUI extends Component {
+  addChild(child: Component): void;
+  removeChild(child: Component): void;
+  clear(): void;
+  setFocus(component: Component | null): void;
+  showOverlay(component: Component, options?: OverlayOptions): OverlayHandle;
+  hideOverlay(): void;
+  hasOverlay(): boolean;
+  requestRender(): void;
+  [key: string]: unknown;
+}
+interface ViewportTUI extends TUI {
+  [key: string]: unknown;
+}
+declare function isViewportTUI(value: unknown): value is ViewportTUI;
+//#endregion
+export { TuiInputListenerResult as $, decodeKittyPrintable as $t, ScrollViewScrollToOptions as A, imageFallback as At, SettingsListTheme as B, Keybindings as Bt, OverlayAnchor as C, truncateToWidth as Cn, getCellDimensions as Ct, OverlayUnfocusOptions as D, getPngDimensions as Dt, OverlayOptions as E, getJpegDimensions as Et, SelectListTheme as F, renderLatex as Ft, StackEntryOptions as G, setKeybindings as Gt, Spacer as H, KeybindingsManager as Ht, SelectListTruncatePrimaryContext as I, Keybinding as It, Text as J, parseOsc11BackgroundColor as Jt, StackOptions as K, RgbColor as Kt, SettingItem as L, KeybindingConflict as Lt, SelectItem as M, setCapabilities as Mt, SelectList as N, setCellDimensions as Nt, ScrollView as O, getWebpDimensions as Ot, SelectListLayoutOptions as P, RenderLatexOptions as Pt, TuiInputListener as Q, KeyId as Qt, SettingsList as R, KeybindingDefinition as Rt, Marked as S, stripTerminalSequences as Sn, getCapabilities as St, OverlayMargin as T, wrapTextWithAnsi as Tn, getImageDimensions as Tt, StackChild as U, TUI_KEYBINDINGS as Ut, SizeValue as V, KeybindingsConfig as Vt, StackEntry as W, getKeybindings as Wt, Tokens as X, Key as Xt, Token as Y, parseTerminalColorSchemeReport as Yt, TruncatedText as Z, KeyEventType as Zt, Loader as _, isPunctuationChar as _n, deleteAllKittyImages as _t, Container as a, setKittyProtocolActive as an, isViewportTUI as at, MarkdownOptions as b, sliceByColumn as bn, encodeITerm2 as bt, EditorComponent as c, fuzzyMatch as cn, AutocompleteSuggestions as ct, Focusable as d, cjkBreakRegex as dn, CellDimensions as dt, isKeyRelease as en, TuiMode as et, HStack as f, extractAnsiCode as fn, ImageDimensions as ft, Input as g, getWordSegmenter as gn, calculateImageRows as gt, ImageTheme as h, getOsc8LinkAtColumn as hn, allocateImageId as ht, Component as i, parseKey as in, isFocusable as it, ScrollViewScrollbar as j, resetCapabilitiesCache as jt, ScrollViewOptions as k, hyperlink as kt, EditorOptions as l, PUNCTUATION_REGEX as ln, CombinedAutocompleteProvider as lt, ImageOptions as m, getGraphemeSegmenter as mn, TerminalCapabilities as mt, CURSOR_MARKER as n, isKittyProtocolActive as nn, VStack as nt, DefaultTextStyle as o, FuzzyMatch as on, AutocompleteItem as ot, Image as p, getGraphemeCellRange as pn, ImageProtocol as pt, TUI as q, TerminalColorScheme as qt, CancellableLoader as r, matchesKey as rn, ViewportTUI as rt, Editor as s, fuzzyFilter as sn, AutocompleteProvider as st, Box as t, isKeyRepeat as tn, TuiStopOptions as tt, EditorTheme as u, applyBackgroundToLine as un, SlashCommand as ut, LoaderIndicatorOptions as v, isWhitespaceChar as vn, deleteKittyImage as vt, OverlayHandle as w, visibleWidth as wn, getGifDimensions as wt, MarkdownTheme as x, sliceWithWidth as xn, encodeKitty as xt, Markdown as y, normalizeTerminalOutput as yn, detectCapabilities as yt, SettingsListOptions as z, KeybindingDefinitions as zt };
+//# sourceMappingURL=pi-tui-iHoF2tFc.d.mts.map