maistro 1.0.390

package/dist/inputBox.js

@@ -0,0 +1,966 @@
+import { mightBePastedImage, detectPastedImage } from './imageManager.js';
+import { getNewlineHint } from './config.js';
+/**
+ * Get the display width of a string (accounts for wide characters like CJK, emoji).
+ * Returns the number of terminal columns the string occupies.
+ */
+export function getDisplayWidth(str) {
+    let width = 0;
+    for (const char of str) {
+        width += getCharWidth(char);
+    }
+    return width;
+}
+/**
+ * Get the display width of a single character.
+ * - East Asian Wide characters (CJK, fullwidth forms): 2
+ * - Most emoji: 2
+ * - Regular ASCII and other characters: 1
+ * - Control characters: 0
+ */
+function getCharWidth(char) {
+    const code = char.codePointAt(0);
+    if (code === undefined)
+        return 0;
+    // Control characters
+    if (code < 0x20 || (code >= 0x7F && code < 0xA0)) {
+        return 0;
+    }
+    // Check for wide characters
+    if (isWideCharacter(code)) {
+        return 2;
+    }
+    return 1;
+}
+/**
+ * Check if a Unicode code point is a wide (2-column) character.
+ */
+function isWideCharacter(code) {
+    // Hangul Jamo
+    if (code >= 0x1100 && code <= 0x115F)
+        return true;
+    // Hangul Compatibility Jamo
+    if (code >= 0x3130 && code <= 0x318F)
+        return true;
+    // CJK Radicals, Kangxi Radicals, CJK Symbols
+    if (code >= 0x2E80 && code <= 0x303F)
+        return true;
+    // Hiragana, Katakana
+    if (code >= 0x3040 && code <= 0x30FF)
+        return true;
+    // Bopomofo, Hangul Compatibility Jamo, Kanbun
+    if (code >= 0x3100 && code <= 0x319F)
+        return true;
+    // Enclosed CJK Letters
+    if (code >= 0x3200 && code <= 0x32FF)
+        return true;
+    // CJK Compatibility
+    if (code >= 0x3300 && code <= 0x33FF)
+        return true;
+    // CJK Unified Ideographs Extension A
+    if (code >= 0x3400 && code <= 0x4DBF)
+        return true;
+    // CJK Unified Ideographs
+    if (code >= 0x4E00 && code <= 0x9FFF)
+        return true;
+    // Yi Syllables and Radicals
+    if (code >= 0xA000 && code <= 0xA4CF)
+        return true;
+    // Hangul Syllables
+    if (code >= 0xAC00 && code <= 0xD7A3)
+        return true;
+    // CJK Compatibility Ideographs
+    if (code >= 0xF900 && code <= 0xFAFF)
+        return true;
+    // Vertical Forms
+    if (code >= 0xFE10 && code <= 0xFE1F)
+        return true;
+    // CJK Compatibility Forms
+    if (code >= 0xFE30 && code <= 0xFE4F)
+        return true;
+    // Halfwidth and Fullwidth Forms (fullwidth range)
+    if (code >= 0xFF00 && code <= 0xFF60)
+        return true;
+    if (code >= 0xFFE0 && code <= 0xFFE6)
+        return true;
+    // Emoji (various ranges)
+    if (code >= 0x1F300 && code <= 0x1F9FF)
+        return true;
+    if (code >= 0x1FA00 && code <= 0x1FAFF)
+        return true;
+    // Supplementary Ideographic Plane
+    if (code >= 0x20000 && code <= 0x2FFFF)
+        return true;
+    // Tertiary Ideographic Plane
+    if (code >= 0x30000 && code <= 0x3FFFF)
+        return true;
+    return false;
+}
+/**
+ * Get the character index that corresponds to a given display column.
+ * Returns the index of the character at or before the column.
+ */
+export function charIndexAtDisplayColumn(str, column) {
+    let width = 0;
+    let index = 0;
+    for (const char of str) {
+        if (width >= column)
+            break;
+        width += getCharWidth(char);
+        index++;
+    }
+    return Math.min(index, [...str].length);
+}
+export class InputBox {
+    inputBuffer;
+    cursorIndex;
+    isFirstRender;
+    escPendingClear;
+    escTimeout;
+    escapeBuffer;
+    escapeTimeout;
+    resolved;
+    options;
+    stdout;
+    stdin;
+    dataHandler;
+    rawModeWasEnabled;
+    // Track preferred column for vertical navigation (like VS Code)
+    preferredVisualCol;
+    // History navigation state
+    historyIndex;
+    savedInput;
+    // Track rendered line count for self-clearing (fixes duplication when onRedraw is empty)
+    lastRenderedLineCount;
+    constructor(options) {
+        this.options = {
+            placeholder: options.placeholder || '',
+            hint: options.hint || 'Enter send',
+            mode: options.mode || 'multi-line',
+            ...options,
+        };
+        this.stdout = options.stdout || process.stdout;
+        this.stdin = options.stdin || process.stdin;
+        this.inputBuffer = options.initialValue || '';
+        this.cursorIndex = this.inputBuffer.length;
+        this.isFirstRender = true;
+        this.escPendingClear = false;
+        this.escTimeout = null;
+        this.escapeBuffer = '';
+        this.escapeTimeout = null;
+        this.resolved = false;
+        this.dataHandler = null;
+        this.rawModeWasEnabled = false;
+        this.preferredVisualCol = null;
+        // History state: -1 means not browsing history (editing current input)
+        this.historyIndex = -1;
+        this.savedInput = '';
+        // Track rendered lines for self-clearing
+        this.lastRenderedLineCount = 0;
+    }
+    /** Get current input value */
+    getValue() {
+        return this.inputBuffer;
+    }
+    /** Set input value programmatically */
+    setValue(value) {
+        this.inputBuffer = value;
+        this.cursorIndex = value.length;
+        this.render();
+    }
+    /** Clear input */
+    clear() {
+        this.inputBuffer = '';
+        this.cursorIndex = 0;
+        this.escPendingClear = false;
+        this.resetHistoryState();
+        this.render();
+    }
+    /** Update history array */
+    setHistory(history) {
+        this.options.history = history;
+    }
+    /** Mark as first render (call after external screen redraw) */
+    markFirstRender() {
+        this.isFirstRender = true;
+    }
+    /** Get current history index (-1 means not browsing history) */
+    getHistoryIndex() {
+        return this.historyIndex;
+    }
+    /** Reset history navigation state (call when user modifies input) */
+    resetHistoryState() {
+        this.historyIndex = -1;
+        this.savedInput = '';
+    }
+    /**
+     * Navigate history in the given direction.
+     * @returns true if navigation occurred, false if at boundary
+     */
+    navigateHistory(direction) {
+        const history = this.options.history;
+        if (!history || history.length === 0)
+            return false;
+        // If custom handler provided, use it
+        if (this.options.onHistoryNavigate) {
+            const newValue = this.options.onHistoryNavigate(direction, this.inputBuffer, this.historyIndex);
+            if (newValue !== null) {
+                // Save current input if just starting history navigation
+                if (this.historyIndex === -1 && direction === 'up') {
+                    this.savedInput = this.inputBuffer;
+                }
+                this.inputBuffer = newValue;
+                this.cursorIndex = newValue.length;
+                // Update history index (managed by callback, but we track for state)
+                if (direction === 'up') {
+                    this.historyIndex = this.historyIndex === -1 ? history.length - 1 : Math.max(0, this.historyIndex - 1);
+                }
+                else {
+                    this.historyIndex = Math.min(history.length, this.historyIndex + 1);
+                    if (this.historyIndex >= history.length) {
+                        this.historyIndex = -1;
+                    }
+                }
+                this.render();
+                return true;
+            }
+            return false;
+        }
+        // Default history navigation logic
+        if (direction === 'up') {
+            if (this.historyIndex === -1) {
+                // Save current input and go to most recent history
+                this.savedInput = this.inputBuffer;
+                this.historyIndex = history.length - 1;
+            }
+            else if (this.historyIndex > 0) {
+                // Go to older history
+                this.historyIndex--;
+            }
+            else {
+                // Already at oldest, do nothing
+                return false;
+            }
+            this.inputBuffer = history[this.historyIndex];
+            this.cursorIndex = this.inputBuffer.length;
+            this.render();
+            return true;
+        }
+        else {
+            // direction === 'down'
+            if (this.historyIndex === -1) {
+                // Not in history, do nothing
+                return false;
+            }
+            else if (this.historyIndex < history.length - 1) {
+                // Go to newer history
+                this.historyIndex++;
+                this.inputBuffer = history[this.historyIndex];
+            }
+            else {
+                // At most recent history, go back to saved input
+                this.historyIndex = -1;
+                this.inputBuffer = this.savedInput;
+            }
+            this.cursorIndex = this.inputBuffer.length;
+            this.render();
+            return true;
+        }
+    }
+    /**
+     * Check if cursor is at the first visual line of input
+     */
+    isAtFirstLine() {
+        const { lineNum, visualRow } = this.getVisualLineInfo();
+        return lineNum === 0 && visualRow === 0;
+    }
+    /**
+     * Check if cursor is at the last visual line of input
+     */
+    isAtLastLine() {
+        const { lineNum, lines, visualRow, totalVisualRows } = this.getVisualLineInfo();
+        return lineNum === lines.length - 1 && visualRow === totalVisualRows - 1;
+    }
+    safeWrite(data) {
+        try {
+            if (this.stdout.writable) {
+                this.stdout.write(data);
+            }
+        }
+        catch {
+            // Ignore write errors
+        }
+    }
+    getTermWidth() {
+        return this.stdout.columns || 80;
+    }
+    getTermHeight() {
+        return this.stdout.rows || 24;
+    }
+    /**
+     * Get cursor position info within multi-line input.
+     * Returns the logical line number and column within that line.
+     */
+    getLineInfo() {
+        const lines = this.inputBuffer.split('\n');
+        let pos = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const lineLen = lines[i].length;
+            if (this.cursorIndex <= pos + lineLen) {
+                return {
+                    lineNum: i,
+                    col: this.cursorIndex - pos,
+                    lines,
+                };
+            }
+            pos += lineLen + 1; // +1 for newline
+        }
+        // Cursor at end
+        return {
+            lineNum: lines.length - 1,
+            col: lines[lines.length - 1].length,
+            lines,
+        };
+    }
+    /**
+     * Get the content width available for text (terminal width minus prefix).
+     * Prefix is "> " for first line and "  " for continuation lines = 2 chars.
+     */
+    getContentWidth() {
+        return Math.max(10, this.getTermWidth() - 2);
+    }
+    /**
+     * Get visual line info for navigation.
+     * Visual lines are what you see on screen after wrapping.
+     * Returns info about which visual row the cursor is on within the current logical line.
+     * Uses display width to account for wide characters (CJK, emoji, etc.).
+     */
+    getVisualLineInfo() {
+        const { lineNum, col, lines } = this.getLineInfo();
+        const contentWidth = this.getContentWidth();
+        const lineContent = lines[lineNum];
+        // Calculate total display width of the line (plus 1 for cursor at end)
+        const lineDisplayWidth = getDisplayWidth(lineContent) + 1;
+        // Calculate how many visual rows this logical line spans
+        const totalVisualRows = Math.max(1, Math.ceil(lineDisplayWidth / contentWidth));
+        // Calculate display column of cursor (width of characters before cursor)
+        const textBeforeCursor = [...lineContent].slice(0, col).join('');
+        const cursorDisplayCol = getDisplayWidth(textBeforeCursor);
+        // Which visual row is the cursor on?
+        const visualRow = Math.floor(cursorDisplayCol / contentWidth);
+        // Display column within this visual row
+        const visualCol = cursorDisplayCol % contentWidth;
+        return {
+            lineNum,
+            col,
+            lines,
+            visualRow,
+            visualCol,
+            totalVisualRows,
+            contentWidth,
+        };
+    }
+    /**
+     * Calculate cursor index from logical line number and column.
+     */
+    cursorIndexFromLineCol(lineNum, col, lines) {
+        let pos = 0;
+        for (let i = 0; i < lineNum; i++) {
+            pos += lines[i].length + 1; // +1 for newline
+        }
+        return pos + Math.min(col, lines[lineNum].length);
+    }
+    /**
+     * Render the input box.
+     * Uses full-screen redraw approach for reliability.
+     * Supports multi-line input with proper cursor positioning.
+     *
+     * Self-clears previous output to prevent duplication when onRedraw is empty.
+     */
+    render() {
+        const termWidth = this.getTermWidth();
+        const border = '─'.repeat(termWidth);
+        const { placeholder, hint, onRedraw } = this.options;
+        // Calculate input line count for onRedraw callback
+        const inputLineCount = this.inputBuffer ? this.inputBuffer.split('\n').length : 1;
+        // Self-clear previous content before calling onRedraw
+        // This prevents duplicate input boxes when navigating history or re-rendering
+        // Only clear if we have previous content (lastRenderedLineCount > 0)
+        if (this.lastRenderedLineCount > 0) {
+            this.safeWrite(`\x1b[${this.lastRenderedLineCount}A`); // Move cursor up
+            this.safeWrite('\x1b[J'); // Clear from cursor to end of screen
+        }
+        // Always call onRedraw to ensure content is drawn
+        // On first render with hideWhen, we especially need this since the InputBox won't draw anything visible
+        onRedraw(inputLineCount);
+        this.isFirstRender = false;
+        // Check if we should hide the input box visually
+        if (this.options.hideWhen?.()) {
+            // Clear any residual content from previous render
+            this.safeWrite('\x1b[J');
+            this.lastRenderedLineCount = 0;
+            return;
+        }
+        // Track VISUAL line count for this render (terminal rows, not logical lines)
+        // This accounts for line wrapping when content exceeds terminal width
+        let visualLineCount = 0;
+        const contentWidth = this.getContentWidth(); // Width available for content after prefix
+        // Top border (always 1 visual line - it exactly fits terminal width)
+        this.safeWrite(`\x1b[90m${border}\x1b[0m\n`);
+        visualLineCount++;
+        // Input line(s) with cursor - supports multi-line
+        if (this.inputBuffer) {
+            // Split input into lines for multi-line display
+            const { lineNum: cursorLine, col: cursorCol, lines } = this.getLineInfo();
+            // Calculate available rows for input (terminal height minus borders, hint, some buffer for content above)
+            // Reserve: 1 top border + 1 bottom border + 1 hint + 2 safety buffer = 5 lines
+            const maxInputLines = Math.max(3, this.getTermHeight() - 5);
+            const totalLines = lines.length;
+            const needsScrolling = totalLines > maxInputLines;
+            // Determine which lines to show (keep cursor line visible)
+            let startLine = 0;
+            let endLine = totalLines;
+            if (needsScrolling) {
+                // Center the cursor line in the visible area, with preference to show context
+                const halfWindow = Math.floor(maxInputLines / 2);
+                startLine = Math.max(0, cursorLine - halfWindow);
+                endLine = Math.min(totalLines, startLine + maxInputLines);
+                // Adjust start if we're near the end
+                if (endLine === totalLines) {
+                    startLine = Math.max(0, totalLines - maxInputLines);
+                }
+            }
+            // Show scroll indicator at top if there are hidden lines above
+            if (startLine > 0) {
+                this.safeWrite(`\x1b[90m  ↑ ${startLine} more line${startLine > 1 ? 's' : ''} above\x1b[0m\n`);
+                visualLineCount++;
+            }
+            // Render visible lines
+            for (let idx = startLine; idx < endLine; idx++) {
+                const line = lines[idx];
+                // First line gets "> ", continuation lines get "  " (same width for alignment)
+                const prefix = idx === 0 ? '\x1b[90m>\x1b[0m ' : '  ';
+                // Show line break indicator (↵) at end of line if not the last line
+                const lineBreakIndicator = idx < totalLines - 1 ? '\x1b[90m↵\x1b[0m' : '';
+                if (idx === cursorLine) {
+                    // This line has the cursor
+                    const beforeCursor = line.slice(0, cursorCol);
+                    const atCursor = line[cursorCol] || ' ';
+                    const afterCursor = line.slice(cursorCol + 1);
+                    this.safeWrite(`${prefix}${beforeCursor}\x1b[7m${atCursor}\x1b[0m${afterCursor}${lineBreakIndicator}\n`);
+                }
+                else {
+                    this.safeWrite(`${prefix}${line}${lineBreakIndicator}\n`);
+                }
+                // Calculate visual lines for this content line (accounting for terminal wrapping)
+                // Line content width = display width of line + prefix (2) + line break indicator (~1 if present)
+                const lineDisplayWidth = getDisplayWidth(line) + 2 + (idx < totalLines - 1 ? 1 : 0);
+                const termWidth = this.getTermWidth();
+                const visualLinesForThisLine = Math.max(1, Math.ceil(lineDisplayWidth / termWidth));
+                visualLineCount += visualLinesForThisLine;
+            }
+            // Show scroll indicator at bottom if there are hidden lines below
+            if (endLine < totalLines) {
+                const hiddenBelow = totalLines - endLine;
+                this.safeWrite(`\x1b[90m  ↓ ${hiddenBelow} more line${hiddenBelow > 1 ? 's' : ''} below\x1b[0m\n`);
+                visualLineCount++;
+            }
+        }
+        else if (placeholder) {
+            this.safeWrite(`\x1b[90m>\x1b[0m \x1b[7m \x1b[0m\x1b[90m${placeholder}\x1b[0m\n`);
+            visualLineCount++;
+        }
+        else {
+            this.safeWrite(`\x1b[90m>\x1b[0m \x1b[7m \x1b[0m\n`);
+            visualLineCount++;
+        }
+        // Bottom border (always 1 visual line)
+        this.safeWrite(`\x1b[90m${border}\x1b[0m\n`);
+        visualLineCount++;
+        // Custom footer or default hint
+        if (this.options.customFooter) {
+            // Let caller render custom footer (e.g., image list + hint)
+            // Note: customFooter is responsible for its own line tracking
+            this.options.customFooter(this.escPendingClear, termWidth);
+            visualLineCount++; // Assume at least 1 line for custom footer
+        }
+        else {
+            // Hint OUTSIDE the input box, right-aligned
+            // Show escape confirmation hint if pending, otherwise normal hint
+            const displayHint = this.escPendingClear ? 'Escape again to clear' : (hint || `Enter send · ${getNewlineHint()}`);
+            const hintColor = this.escPendingClear ? '\x1b[33m' : '\x1b[90m'; // Yellow for warning
+            // Use ANSI cursor positioning to right-align hint reliably (move cursor to column)
+            // Use display width for proper alignment with non-ASCII characters
+            const hintCol = Math.max(1, termWidth - getDisplayWidth(displayHint) + 1);
+            this.safeWrite(`\x1b[${hintCol}G${hintColor}${displayHint}\x1b[0m\n`);
+            visualLineCount++;
+        }
+        // Clear any residual content below (from previous longer input/wrapping)
+        this.safeWrite('\x1b[J');
+        // Save visual line count for next render's self-clear
+        this.lastRenderedLineCount = visualLineCount;
+    }
+    /**
+     * Handle a key press
+     */
+    handleKey(key) {
+        if (this.resolved) {
+            return;
+        }
+        // Let custom handler try first
+        if (this.options.onKey && this.options.onKey(key, this)) {
+            return;
+        }
+        // Handle escape sequence buffering
+        if (this.escapeBuffer) {
+            key = this.escapeBuffer + key;
+            this.escapeBuffer = '';
+            if (this.escapeTimeout) {
+                clearTimeout(this.escapeTimeout);
+                this.escapeTimeout = null;
+            }
+        }
+        // Bare escape - wait briefly for more input (could be start of sequence)
+        if (key === '\x1b') {
+            this.escapeBuffer = key;
+            this.escapeTimeout = setTimeout(() => {
+                this.escapeBuffer = '';
+                this.handleBareEscape();
+            }, 50);
+            return;
+        }
+        // Clear escape pending state on any other input
+        if (this.escPendingClear && key !== '\x1b') {
+            if (this.escTimeout) {
+                clearTimeout(this.escTimeout);
+                this.escTimeout = null;
+            }
+            this.escPendingClear = false;
+            // Will re-render below with normal hint
+        }
+        // Ctrl+C - cancel
+        if (key === '\x03') {
+            this.cleanup();
+            this.options.onCancel?.();
+            return;
+        }
+        // Clipboard paste - check system clipboard for images
+        // Supported sequences:
+        // - \x16 (Ctrl+V) - standard control character
+        // - \x1b[118;9u (Kitty protocol Cmd+V) - 118='v', 9=Super modifier
+        // - \x1bOV (configurable in iTerm2 for Cmd+V)
+        const isPasteKey = key === '\x16' || key === '\x1b[118;9u' || key === '\x1bOV';
+        if (isPasteKey && this.options.onClipboardPaste) {
+            this.options.onClipboardPaste().then(() => {
+                // Re-render after paste completes (callback may have redrawn screen)
+                this.isFirstRender = true;
+                this.render();
+            }).catch(() => {
+                // Re-render even on error
+                this.isFirstRender = true;
+                this.render();
+            });
+            return;
+        }
+        // Shift+Up/Down - history navigation (if shiftArrowHistory enabled or no multi-line)
+        // Kitty protocol: \x1b[1;2A (Shift+Up), \x1b[1;2B (Shift+Down)
+        if (key === '\x1b[1;2A') { // Shift+Up
+            if (this.options.shiftArrowHistory || this.options.mode === 'single-line') {
+                if (this.navigateHistory('up'))
+                    return;
+            }
+            // Fall through to normal up handling if history nav didn't happen
+        }
+        if (key === '\x1b[1;2B') { // Shift+Down
+            if (this.options.shiftArrowHistory || this.options.mode === 'single-line') {
+                if (this.navigateHistory('down'))
+                    return;
+            }
+            // Fall through to normal down handling if history nav didn't happen
+        }
+        // Shift+Enter - insert newline (multi-line input only)
+        // Common sequences: \x1b[13;2u (kitty/modern), \x1bOM (some terminals), or \x0a (Ctrl+J / some Shift+Enter)
+        if (key === '\x1b[13;2u' || key === '\x1bOM' || key === '\x0a') {
+            // Only allow newlines in multi-line mode
+            if (this.options.mode === 'single-line') {
+                // In single-line mode, treat as submit (like Enter)
+                this.cleanup();
+                this.options.onSubmit?.(this.inputBuffer.trim());
+                return;
+            }
+            this.inputBuffer = this.inputBuffer.slice(0, this.cursorIndex) + '\n' + this.inputBuffer.slice(this.cursorIndex);
+            this.cursorIndex++;
+            this.resetHistoryState(); // User modified input, reset history
+            this.render();
+            this.options.onChange?.(this.inputBuffer);
+            return;
+        }
+        // Enter - submit (only plain Enter \r, not \n which may be Shift+Enter)
+        // Also handle batched input like "run\r" or "run\r\n" when typing quickly or pasting
+        const endsWithEnter = key === '\r' || key.endsWith('\r') || key.endsWith('\r\n');
+        if (endsWithEnter) {
+            // If batched input, add the content before Enter to the buffer first
+            const enterSuffix = key.endsWith('\r\n') ? '\r\n' : (key.endsWith('\r') ? '\r' : '');
+            if (enterSuffix && key.length > enterSuffix.length) {
+                const contentBeforeEnter = key.slice(0, -enterSuffix.length);
+                // Only insert printable characters
+                let charsToInsert = '';
+                for (const c of contentBeforeEnter) {
+                    const code = c.charCodeAt(0);
+                    if ((code >= 32 && code < 127) || code >= 128) {
+                        charsToInsert += c;
+                    }
+                }
+                if (charsToInsert.length > 0) {
+                    this.inputBuffer = this.inputBuffer.slice(0, this.cursorIndex) + charsToInsert + this.inputBuffer.slice(this.cursorIndex);
+                    this.cursorIndex += charsToInsert.length;
+                }
+            }
+            this.cleanup();
+            this.options.onSubmit?.(this.inputBuffer.trim());
+            return;
+        }
+        // Arrow keys
+        if (key === '\x1b[D') { // Left
+            if (this.cursorIndex > 0) {
+                this.cursorIndex--;
+                this.preferredVisualCol = null; // Reset preferred column on horizontal movement
+                this.render();
+            }
+            return;
+        }
+        if (key === '\x1b[C') { // Right
+            if (this.cursorIndex < this.inputBuffer.length) {
+                this.cursorIndex++;
+                this.preferredVisualCol = null; // Reset preferred column on horizontal movement
+                this.render();
+            }
+            return;
+        }
+        if (key === '\x1b[A') { // Up - move to previous visual line
+            const { lineNum, lines, visualRow, visualCol, totalVisualRows, contentWidth } = this.getVisualLineInfo();
+            const atFirstLine = lineNum === 0 && visualRow === 0;
+            // At first line: check for boundary navigation or history
+            if (atFirstLine) {
+                // Try boundary navigation callback first
+                if (this.options.onBoundaryNavigation?.('up')) {
+                    return;
+                }
+                // Try history navigation (if not using shiftArrowHistory mode)
+                if (!this.options.shiftArrowHistory && this.options.history) {
+                    if (this.navigateHistory('up'))
+                        return;
+                }
+                // Nothing to do, already at top
+                return;
+            }
+            // Set preferred column if not already set (for maintaining horizontal position)
+            // preferredVisualCol is a display column, not character index
+            if (this.preferredVisualCol === null) {
+                this.preferredVisualCol = visualCol;
+            }
+            if (visualRow > 0) {
+                // Move up within the same logical line (to previous visual row)
+                // Calculate target display column on the previous visual row
+                const targetDisplayCol = (visualRow - 1) * contentWidth + Math.min(this.preferredVisualCol, contentWidth - 1);
+                // Convert display column to character index
+                const newCol = charIndexAtDisplayColumn(lines[lineNum], targetDisplayCol);
+                this.cursorIndex = this.cursorIndexFromLineCol(lineNum, newCol, lines);
+            }
+            else if (lineNum > 0) {
+                // Move to the previous logical line's last visual row
+                const prevLine = lines[lineNum - 1];
+                const prevLineDisplayWidth = getDisplayWidth(prevLine) + 1;
+                const prevTotalVisualRows = Math.max(1, Math.ceil(prevLineDisplayWidth / contentWidth));
+                // Target the last visual row of the previous line, at preferred column
+                const targetDisplayCol = (prevTotalVisualRows - 1) * contentWidth + Math.min(this.preferredVisualCol, contentWidth - 1);
+                const newCol = charIndexAtDisplayColumn(prevLine, targetDisplayCol);
+                this.cursorIndex = this.cursorIndexFromLineCol(lineNum - 1, newCol, lines);
+            }
+            this.render();
+            return;
+        }
+        if (key === '\x1b[B') { // Down - move to next visual line
+            const { lineNum, lines, visualRow, visualCol, totalVisualRows, contentWidth } = this.getVisualLineInfo();
+            const atLastLine = lineNum === lines.length - 1 && visualRow === totalVisualRows - 1;
+            // At last line: check for boundary navigation or history
+            if (atLastLine) {
+                // Try boundary navigation callback first
+                if (this.options.onBoundaryNavigation?.('down')) {
+                    return;
+                }
+                // Try history navigation (if not using shiftArrowHistory mode)
+                if (!this.options.shiftArrowHistory && this.options.history) {
+                    if (this.navigateHistory('down'))
+                        return;
+                }
+                // Nothing to do, already at bottom
+                return;
+            }
+            // Set preferred column if not already set
+            // preferredVisualCol is a display column, not character index
+            if (this.preferredVisualCol === null) {
+                this.preferredVisualCol = visualCol;
+            }
+            if (visualRow < totalVisualRows - 1) {
+                // Move down within the same logical line (to next visual row)
+                // Calculate target display column on the next visual row
+                const targetDisplayCol = (visualRow + 1) * contentWidth + Math.min(this.preferredVisualCol, contentWidth - 1);
+                // Convert display column to character index
+                const newCol = charIndexAtDisplayColumn(lines[lineNum], targetDisplayCol);
+                this.cursorIndex = this.cursorIndexFromLineCol(lineNum, newCol, lines);
+            }
+            else if (lineNum < lines.length - 1) {
+                // Move to the next logical line's first visual row
+                const nextLine = lines[lineNum + 1];
+                // Target the first visual row of the next line, at preferred column
+                const newCol = charIndexAtDisplayColumn(nextLine, this.preferredVisualCol);
+                this.cursorIndex = this.cursorIndexFromLineCol(lineNum + 1, newCol, lines);
+            }
+            this.render();
+            return;
+        }
+        // Home key or Ctrl+A - handle various terminal sequences
+        // CSI H, CSI 1~, SS3 H, CSI 7~ (rxvt), Ctrl+A
+        if (key === '\x1b[H' || key === '\x1b[1~' || key === '\x1bOH' || key === '\x1b[7~' || key === '\x01') {
+            this.cursorIndex = 0;
+            this.preferredVisualCol = null; // Reset on horizontal movement
+            this.render();
+            return;
+        }
+        // End key or Ctrl+E - handle various terminal sequences
+        // CSI F, CSI 4~, SS3 F, CSI 8~ (rxvt), Ctrl+E
+        if (key === '\x1b[F' || key === '\x1b[4~' || key === '\x1bOF' || key === '\x1b[8~' || key === '\x05') {
+            this.cursorIndex = this.inputBuffer.length;
+            this.preferredVisualCol = null; // Reset on horizontal movement
+            this.render();
+            return;
+        }
+        // Backspace
+        if (key === '\x7f' || key === '\b') {
+            if (this.cursorIndex > 0) {
+                this.inputBuffer = this.inputBuffer.slice(0, this.cursorIndex - 1) + this.inputBuffer.slice(this.cursorIndex);
+                this.cursorIndex--;
+                this.preferredVisualCol = null; // Reset on text modification
+                this.resetHistoryState(); // User modified input, reset history
+                this.render();
+                this.options.onChange?.(this.inputBuffer);
+            }
+            return;
+        }
+        // Delete
+        if (key === '\x1b[3~') {
+            if (this.cursorIndex < this.inputBuffer.length) {
+                this.inputBuffer = this.inputBuffer.slice(0, this.cursorIndex) + this.inputBuffer.slice(this.cursorIndex + 1);
+                this.preferredVisualCol = null; // Reset on text modification
+                this.resetHistoryState(); // User modified input, reset history
+                this.render();
+                this.options.onChange?.(this.inputBuffer);
+            }
+            return;
+        }
+        // Ignore other escape sequences
+        if (key.startsWith('\x1b[') || key.startsWith('\x1bO')) {
+            return;
+        }
+        // Regular printable characters (and newlines for pasted multi-line text)
+        // Handle different line ending styles: \n (Unix), \r (old Mac), \r\n (Windows)
+        let charsToInsert = '';
+        for (let i = 0; i < key.length; i++) {
+            const c = key[i];
+            if (c >= ' ' && c !== '\x7f') {
+                // Regular printable character
+                charsToInsert += c;
+            }
+            else if (c === '\n') {
+                // Unix newline
+                charsToInsert += '\n';
+            }
+            else if (c === '\r') {
+                // Carriage return - convert to newline
+                // Skip following \n if this is \r\n (Windows line ending)
+                if (key[i + 1] === '\n') {
+                    i++; // Skip the \n
+                }
+                charsToInsert += '\n';
+            }
+        }
+        if (charsToInsert.length > 0) {
+            // Check for pasted image data before inserting as text
+            if (this.options.onImagePaste && mightBePastedImage(charsToInsert)) {
+                const detection = detectPastedImage(charsToInsert);
+                if (detection.detected) {
+                    // Call the handler - it may be async
+                    const result = this.options.onImagePaste(charsToInsert, detection);
+                    if (result instanceof Promise) {
+                        // Handle async callback
+                        result.then((handled) => {
+                            if (!handled) {
+                                // If not handled, insert the text anyway
+                                this.insertText(charsToInsert);
+                            }
+                        }).catch(() => {
+                            // On error, insert the text
+                            this.insertText(charsToInsert);
+                        });
+                    }
+                    else if (result) {
+                        // Synchronously handled - don't insert text
+                        return;
+                    }
+                    else {
+                        // Not handled - insert the text
+                        this.insertText(charsToInsert);
+                    }
+                    return;
+                }
+            }
+            this.insertText(charsToInsert);
+        }
+    }
+    /**
+     * Insert text at current cursor position
+     */
+    insertText(text) {
+        // In single-line mode, strip newlines from inserted text
+        let textToInsert = text;
+        if (this.options.mode === 'single-line') {
+            textToInsert = text.replace(/\n/g, ' ');
+        }
+        this.inputBuffer = this.inputBuffer.slice(0, this.cursorIndex) + textToInsert + this.inputBuffer.slice(this.cursorIndex);
+        this.cursorIndex += textToInsert.length;
+        this.preferredVisualCol = null; // Reset on text insertion
+        this.resetHistoryState(); // User modified input, reset history
+        this.render();
+        this.options.onChange?.(this.inputBuffer);
+    }
+    /**
+     * Handle bare escape key (no sequence following)
+     */
+    handleBareEscape() {
+        if (this.resolved)
+            return;
+        // If input is empty, just cancel
+        if (!this.inputBuffer) {
+            this.cleanup();
+            this.options.onCancel?.();
+            return;
+        }
+        // If already pending clear, this is the second escape - clear the input
+        if (this.escPendingClear) {
+            if (this.escTimeout) {
+                clearTimeout(this.escTimeout);
+                this.escTimeout = null;
+            }
+            this.escPendingClear = false;
+            this.clear();
+            this.options.onChange?.('');
+            return;
+        }
+        // First escape with text - show confirmation hint
+        this.escPendingClear = true;
+        this.render();
+        // Auto-reset after 1 second
+        this.escTimeout = setTimeout(() => {
+            this.escPendingClear = false;
+            this.escTimeout = null;
+            if (!this.resolved) {
+                this.render();
+            }
+        }, 1000);
+    }
+    /**
+     * Clean up and stop listening
+     */
+    cleanup() {
+        if (this.resolved)
+            return;
+        this.resolved = true;
+        if (this.escTimeout) {
+            clearTimeout(this.escTimeout);
+            this.escTimeout = null;
+        }
+        if (this.escapeTimeout) {
+            clearTimeout(this.escapeTimeout);
+            this.escapeTimeout = null;
+        }
+        if (this.dataHandler) {
+            this.stdin.removeListener('data', this.dataHandler);
+            this.dataHandler = null;
+        }
+        // Restore raw mode state
+        if (this.stdin.setRawMode && !this.rawModeWasEnabled) {
+            this.stdin.setRawMode(false);
+        }
+        this.safeWrite('\n');
+    }
+    /**
+     * Start listening for input
+     */
+    start() {
+        this.resolved = false;
+        this.isFirstRender = true;
+        // Enable raw mode
+        this.rawModeWasEnabled = !!this.stdin.isRaw;
+        if (this.stdin.setRawMode) {
+            this.stdin.setRawMode(true);
+        }
+        this.stdin.resume?.();
+        // Set up key handler
+        this.dataHandler = (key) => {
+            this.handleKey(key.toString());
+        };
+        this.stdin.on('data', this.dataHandler);
+        // Initial render
+        this.render();
+    }
+    /**
+     * Run as a promise (convenience method)
+     */
+    prompt() {
+        return new Promise((resolve) => {
+            const originalOnSubmit = this.options.onSubmit;
+            const originalOnCancel = this.options.onCancel;
+            this.options.onSubmit = (value) => {
+                originalOnSubmit?.(value);
+                resolve(value);
+            };
+            this.options.onCancel = () => {
+                originalOnCancel?.();
+                resolve(null);
+            };
+            this.start();
+        });
+    }
+}
+/**
+ * Create and run an InputBox as a promise
+ */
+export async function inputBox(options) {
+    const box = new InputBox(options);
+    return box.prompt();
+}
+// === Factory methods for common use cases ===
+/**
+ * Create a single-line InputBox (no multi-line support)
+ */
+export function singleLineInput(options) {
+    return new InputBox({ ...options, mode: 'single-line' });
+}
+/**
+ * Create an InputBox with history navigation support
+ */
+export function inputWithHistory(options) {
+    return new InputBox({ ...options, mode: 'multi-line' });
+}
+/**
+ * Create a single-line InputBox with history navigation
+ */
+export function singleLineWithHistory(options) {
+    return new InputBox({
+        ...options,
+        mode: 'single-line',
+        shiftArrowHistory: true, // Use Shift+Up/Down for history in single-line mode
+    });
+}
+//# sourceMappingURL=inputBox.js.map