opencode-agora 0.2.2 → 0.4.0

package/dist/cli/prompter.js

@@ -0,0 +1,675 @@
+/**
+ * Raw-mode line editor with tab completion, ghost-text suggestions, and
+ * history navigation. The public surface is readLine(); the internal state
+ * machine is exposed via applyKeyEvent() for unit testing without I/O.
+ */
+export function makeInitialState(history) {
+    return {
+        line: '',
+        cursor: 0,
+        history,
+        historyIndex: history.length,
+        draft: '',
+        ghost: null,
+        mode: 'normal',
+        searchQuery: '',
+        searchIndex: -1,
+        tabCycle: null
+    };
+}
+// ── Pure state machine ──────────────────────────────────────────────────────
+export function applyKeyEvent(state, event, opts = {}) {
+    // Reverse-i-search mode has its own dispatch
+    if (state.mode === 'reverse-search') {
+        return applySearchEvent(state, event);
+    }
+    switch (event.kind) {
+        case 'ctrl-c':
+            return { state, output: { kind: 'abort' } };
+        case 'ctrl-d': {
+            if (state.line === '') {
+                return { state, output: { kind: 'eof' } };
+            }
+            // Forward delete
+            const chars = Array.from(state.line);
+            if (state.cursor < chars.length) {
+                chars.splice(state.cursor, 1);
+                const next = withGhost({ ...state, line: chars.join('') }, opts);
+                return { state: next };
+            }
+            return { state };
+        }
+        case 'enter': {
+            const next = { ...state, ghost: null, tabCycle: null };
+            return { state: next, output: { kind: 'line', value: state.line } };
+        }
+        case 'char': {
+            const chars = Array.from(state.line);
+            chars.splice(state.cursor, 0, ...Array.from(event.data));
+            const newCursor = state.cursor + Array.from(event.data).length;
+            const newLine = chars.join('');
+            const next = withGhost({ ...state, line: newLine, cursor: newCursor, tabCycle: null }, opts);
+            // Auto-complete: show slash-command completions as soon as '/' is typed
+            if (newLine.startsWith('/') && opts.completer) {
+                const result = opts.completer(newLine, newCursor);
+                if (result.matches.length > 0) {
+                    return { state: next, sideEffect: 'show-completions', completionsToShow: result.matches.slice(0, 6) };
+                }
+            }
+            return { state: next };
+        }
+        case 'backspace': {
+            if (state.cursor === 0)
+                return { state };
+            const chars = Array.from(state.line);
+            chars.splice(state.cursor - 1, 1);
+            const newLine = chars.join('');
+            const next = withGhost({ ...state, line: newLine, cursor: state.cursor - 1, tabCycle: null }, opts);
+            // Auto-complete: update slash-command completions when backspacing inside a slash prefix
+            if (newLine.startsWith('/') && opts.completer) {
+                const result = opts.completer(newLine, Math.min(newLine.length, state.cursor - 1));
+                if (result.matches.length > 0) {
+                    return { state: next, sideEffect: 'show-completions', completionsToShow: result.matches.slice(0, 6) };
+                }
+            }
+            return { state: next };
+        }
+        case 'left': {
+            const next = { ...state, cursor: Math.max(0, state.cursor - 1), tabCycle: null };
+            return { state: next };
+        }
+        case 'right': {
+            const chars = Array.from(state.line);
+            if (state.cursor >= chars.length && state.ghost) {
+                // Accept ghost
+                const newLine = state.line + state.ghost;
+                const next = withGhost({ ...state, line: newLine, cursor: newLine.length, ghost: null, tabCycle: null }, opts);
+                return { state: next };
+            }
+            const next = {
+                ...state,
+                cursor: Math.min(chars.length, state.cursor + 1),
+                tabCycle: null
+            };
+            return { state: next };
+        }
+        case 'ctrl-f': {
+            const chars = Array.from(state.line);
+            if (state.cursor >= chars.length && state.ghost) {
+                const newLine = state.line + state.ghost;
+                const next = withGhost({ ...state, line: newLine, cursor: newLine.length, ghost: null, tabCycle: null }, opts);
+                return { state: next };
+            }
+            const next = {
+                ...state,
+                cursor: Math.min(chars.length, state.cursor + 1),
+                tabCycle: null
+            };
+            return { state: next };
+        }
+        case 'home': {
+            return { state: { ...state, cursor: 0, tabCycle: null } };
+        }
+        case 'end': {
+            return { state: { ...state, cursor: Array.from(state.line).length, tabCycle: null } };
+        }
+        case 'up': {
+            if (state.historyIndex <= 0)
+                return { state };
+            const saveDraft = state.historyIndex === state.history.length ? state.line : state.draft;
+            const newIndex = state.historyIndex - 1;
+            const newLine = state.history[newIndex] ?? '';
+            const next = withGhost({
+                ...state,
+                line: newLine,
+                cursor: Array.from(newLine).length,
+                historyIndex: newIndex,
+                draft: saveDraft,
+                tabCycle: null
+            }, opts);
+            return { state: next };
+        }
+        case 'down': {
+            if (state.historyIndex >= state.history.length)
+                return { state };
+            const newIndex = state.historyIndex + 1;
+            const newLine = newIndex === state.history.length ? state.draft : (state.history[newIndex] ?? '');
+            const next = withGhost({
+                ...state,
+                line: newLine,
+                cursor: Array.from(newLine).length,
+                historyIndex: newIndex,
+                tabCycle: null
+            }, opts);
+            return { state: next };
+        }
+        case 'ctrl-l': {
+            return { state, sideEffect: 'clear-screen' };
+        }
+        case 'ctrl-r': {
+            const searchIdx = findPrevMatch(state.history, state.searchQuery, state.history.length - 1);
+            return {
+                state: {
+                    ...state,
+                    mode: 'reverse-search',
+                    searchQuery: '',
+                    searchIndex: searchIdx,
+                    tabCycle: null
+                }
+            };
+        }
+        case 'ctrl-w': {
+            // Delete word backward
+            const chars = Array.from(state.line);
+            let pos = state.cursor;
+            // Skip trailing spaces
+            while (pos > 0 && chars[pos - 1] === ' ')
+                pos -= 1;
+            // Delete word chars
+            while (pos > 0 && chars[pos - 1] !== ' ')
+                pos -= 1;
+            chars.splice(pos, state.cursor - pos);
+            const next = withGhost({ ...state, line: chars.join(''), cursor: pos, tabCycle: null }, opts);
+            return { state: next };
+        }
+        case 'ctrl-u': {
+            const chars = Array.from(state.line);
+            chars.splice(0, state.cursor);
+            const next = withGhost({ ...state, line: chars.join(''), cursor: 0, tabCycle: null }, opts);
+            return { state: next };
+        }
+        case 'ctrl-k': {
+            const chars = Array.from(state.line);
+            const newLine = chars.slice(0, state.cursor).join('');
+            const next = withGhost({ ...state, line: newLine, tabCycle: null }, opts);
+            return { state: next };
+        }
+        case 'esc': {
+            return { state: { ...state, ghost: null, tabCycle: null } };
+        }
+        case 'tab': {
+            if (!opts.completer)
+                return { state };
+            // If there's an active tabCycle, cycle through its stored matches
+            if (state.tabCycle && state.tabCycle.matches.length > 1) {
+                const nextIndex = (state.tabCycle.index + 1) % state.tabCycle.matches.length;
+                const match = state.tabCycle.matches[nextIndex];
+                const newLine = spliceMatch(state.line, state.tabCycle.replaceFrom, state.cursor, match);
+                const next = withGhost({
+                    ...state,
+                    line: newLine,
+                    cursor: state.tabCycle.replaceFrom + Array.from(match).length,
+                    tabCycle: { ...state.tabCycle, index: nextIndex }
+                }, opts);
+                return { state: next };
+            }
+            const result = opts.completer(state.line, state.cursor);
+            if (result.matches.length === 0)
+                return { state };
+            if (result.matches.length === 1) {
+                const match = result.matches[0];
+                const newLine = spliceMatch(state.line, result.replaceFrom, state.cursor, match);
+                const newCursor = result.replaceFrom + Array.from(match).length;
+                const next = withGhost({ ...state, line: newLine, cursor: newCursor, tabCycle: null }, opts);
+                return { state: next };
+            }
+            // Multiple matches: show list, replace with longest common prefix
+            const lcp = longestCommonPrefix(result.matches);
+            const newLine = spliceMatch(state.line, result.replaceFrom, state.cursor, lcp);
+            const newCursor = result.replaceFrom + Array.from(lcp).length;
+            const next = withGhost({
+                ...state,
+                line: newLine,
+                cursor: newCursor,
+                tabCycle: { matches: result.matches, index: -1, replaceFrom: result.replaceFrom }
+            }, opts);
+            return {
+                state: next,
+                sideEffect: 'show-completions',
+                completionsToShow: result.matches.slice(0, 6)
+            };
+        }
+        default:
+            return { state };
+    }
+}
+// ── Reverse-i-search ─────────────────────────────────────────────────────────
+function applySearchEvent(state, event) {
+    if (event.kind === 'esc') {
+        return {
+            state: {
+                ...state,
+                mode: 'normal',
+                searchQuery: '',
+                searchIndex: -1
+            }
+        };
+    }
+    if (event.kind === 'enter') {
+        const matched = state.searchIndex >= 0 ? (state.history[state.searchIndex] ?? '') : state.line;
+        return {
+            state: {
+                ...state,
+                mode: 'normal',
+                line: matched,
+                cursor: Array.from(matched).length,
+                searchQuery: '',
+                searchIndex: -1
+            },
+            output: { kind: 'line', value: matched }
+        };
+    }
+    if (event.kind === 'ctrl-r') {
+        // Cycle to older match
+        const startFrom = state.searchIndex > 0 ? state.searchIndex - 1 : state.history.length - 1;
+        const nextIdx = findPrevMatch(state.history, state.searchQuery, startFrom);
+        return { state: { ...state, searchIndex: nextIdx } };
+    }
+    if (event.kind === 'ctrl-c') {
+        return {
+            state: { ...state, mode: 'normal', searchQuery: '', searchIndex: -1 },
+            output: { kind: 'abort' }
+        };
+    }
+    if (event.kind === 'backspace') {
+        const newQuery = state.searchQuery.slice(0, -1);
+        const idx = findPrevMatch(state.history, newQuery, state.history.length - 1);
+        return { state: { ...state, searchQuery: newQuery, searchIndex: idx } };
+    }
+    if (event.kind === 'char') {
+        const newQuery = state.searchQuery + event.data;
+        const idx = findPrevMatch(state.history, newQuery, state.history.length - 1);
+        return { state: { ...state, searchQuery: newQuery, searchIndex: idx } };
+    }
+    return { state };
+}
+function findPrevMatch(history, query, startFrom) {
+    if (!query)
+        return -1;
+    for (let i = startFrom; i >= 0; i -= 1) {
+        if (history[i].includes(query))
+            return i;
+    }
+    return -1;
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function withGhost(state, opts) {
+    if (!opts.ghostSuggester)
+        return { ...state, ghost: null };
+    const ghost = opts.ghostSuggester(state.line, state.history);
+    return { ...state, ghost };
+}
+function spliceMatch(line, replaceFrom, cursor, match) {
+    const chars = Array.from(line);
+    chars.splice(replaceFrom, cursor - replaceFrom, ...Array.from(match));
+    return chars.join('');
+}
+function longestCommonPrefix(strs) {
+    if (strs.length === 0)
+        return '';
+    let prefix = strs[0];
+    for (let i = 1; i < strs.length; i += 1) {
+        while (!strs[i].startsWith(prefix)) {
+            prefix = prefix.slice(0, -1);
+            if (!prefix)
+                return '';
+        }
+    }
+    return prefix;
+}
+// ── Rendering helpers ────────────────────────────────────────────────────────
+/** Visible cell width of a string with ANSI CSI escape sequences stripped. */
+export function visibleWidth(s) {
+    // eslint-disable-next-line no-control-regex
+    return Array.from(s.replace(/\x1b\[[0-9;]*m/g, '')).length;
+}
+const EMPTY_FRAME_POSITION = { totalRows: 0, cursorRow: 0, promptRows: 0 };
+/**
+ * Returns the ANSI bytes that paint a fresh prompt frame and the position
+ * the new frame occupies. Pass `width` (terminal columns) and `prev` (the
+ * previous frame's position) so the renderer can erase exactly the rows
+ * that were previously drawn — including any that wrapped past the
+ * declared width. With `width=Infinity` (default) the wrapping math
+ * collapses to legacy single-row behaviour and the only redraw side-effect
+ * is the leading `\r\x1b[K` that clears the current row.
+ */
+export function renderPromptFrame(state, prompt, footer, width = Infinity, prev = EMPTY_FRAME_POSITION) {
+    const safeWidth = Number.isFinite(width) && width > 0 ? width : Infinity;
+    const wrapRows = (text) => {
+        if (!Number.isFinite(safeWidth))
+            return 1;
+        const w = visibleWidth(text);
+        return Math.max(1, Math.ceil(Math.max(1, w) / safeWidth));
+    };
+    const chars = Array.from(state.line);
+    const before = chars.slice(0, state.cursor).join('');
+    const after = chars.slice(state.cursor).join('');
+    const ghostAnsi = state.ghost ? `\x1b[2m${state.ghost}\x1b[0m` : '';
+    const suffix = after + ghostAnsi;
+    const promptVisible = visibleWidth(prompt);
+    const beforeLen = Array.from(before).length;
+    const afterLen = Array.from(after).length;
+    const ghostLen = Array.from(state.ghost ?? '').length;
+    const promptTotalVisible = promptVisible + beforeLen + afterLen + ghostLen;
+    const promptRows = Number.isFinite(safeWidth)
+        ? Math.max(1, Math.ceil(Math.max(1, promptTotalVisible) / safeWidth))
+        : 1;
+    const cursorLogicalCol = promptVisible + beforeLen;
+    const cursorRow = Number.isFinite(safeWidth)
+        ? Math.floor(cursorLogicalCol / safeWidth)
+        : 0;
+    const cursorCol = Number.isFinite(safeWidth)
+        ? cursorLogicalCol % safeWidth
+        : cursorLogicalCol;
+    const footerLines = footer ? footer.split('\n') : [];
+    const footerRowsPhysical = footerLines.reduce((sum, line) => sum + wrapRows(line), 0);
+    const totalRows = promptRows + footerRowsPhysical;
+    let frame = '';
+    if (prev.totalRows > 0) {
+        // Erase the previous frame: go to its top-left corner, then clear from
+        // there to the end of the screen. This wipes any wrapped continuation
+        // rows that single-row `\r\x1b[K` would have missed.
+        frame += '\r';
+        if (prev.cursorRow > 0)
+            frame += `\x1b[${prev.cursorRow}A`;
+        frame += '\x1b[J';
+    }
+    else {
+        // First render: assume the row we're on may have stale content and clear it.
+        frame += '\r\x1b[K';
+    }
+    frame += prompt + before + suffix;
+    if (footer) {
+        for (const line of footerLines) {
+            frame += '\n\r\x1b[K' + line;
+        }
+    }
+    // After writing, terminal cursor sits at the end of the last printed text.
+    // `\r` brings it to col 0 of the row it ended up on (the last physical row
+    // of the last logical line). Move up to the target cursor row, then right.
+    frame += '\r';
+    const endRow = totalRows - 1;
+    const moveUp = endRow - cursorRow;
+    if (moveUp > 0)
+        frame += `\x1b[${moveUp}A`;
+    if (cursorCol > 0)
+        frame += `\x1b[${cursorCol}C`;
+    return {
+        frame,
+        position: { totalRows, cursorRow, promptRows }
+    };
+}
+function renderSearch(state, _prompt) {
+    const matched = state.searchIndex >= 0 ? (state.history[state.searchIndex] ?? '') : '';
+    return `\r\x1b[K(reverse-i-search)\`${state.searchQuery}\`: ${matched}`;
+}
+// ── Main readLine ────────────────────────────────────────────────────────────
+export async function readLine(opts) {
+    const out = opts.out ?? process.stdout;
+    const inp = opts.in ?? process.stdin;
+    return new Promise((resolve) => {
+        let state = makeInitialState(opts.history);
+        // Compute initial ghost
+        if (opts.ghostSuggester) {
+            state = { ...state, ghost: opts.ghostSuggester('', opts.history) };
+        }
+        // Emit initial prompt (with suffix computed for empty initial line)
+        out.write(opts.prompt + (opts.promptSuffix ? opts.promptSuffix('') : ''));
+        // Accumulated escape sequence buffer
+        let escBuf = '';
+        let escTimer = null;
+        function flushEsc() {
+            if (escTimer) {
+                clearTimeout(escTimer);
+                escTimer = null;
+            }
+            if (!escBuf)
+                return;
+            const seq = escBuf;
+            escBuf = '';
+            dispatchEscSequence(seq);
+        }
+        function dispatchEscSequence(seq) {
+            // Arrow keys and navigation
+            if (seq === '\x1b[A' || seq === '\x1bOA')
+                return dispatchEvent({ kind: 'up' });
+            if (seq === '\x1b[B' || seq === '\x1bOB')
+                return dispatchEvent({ kind: 'down' });
+            if (seq === '\x1b[C' || seq === '\x1bOC')
+                return dispatchEvent({ kind: 'right' });
+            if (seq === '\x1b[D' || seq === '\x1bOD')
+                return dispatchEvent({ kind: 'left' });
+            if (seq === '\x1b[H' || seq === '\x1bOH')
+                return dispatchEvent({ kind: 'home' });
+            if (seq === '\x1b[F' || seq === '\x1bOF')
+                return dispatchEvent({ kind: 'end' });
+            // Bare Esc
+            if (seq === '\x1b')
+                return dispatchEvent({ kind: 'esc' });
+        }
+        // Position of the last redraw; threaded into the next call so we can
+        // clear exactly the rows we drew (including wrapped continuations).
+        let framePos = EMPTY_FRAME_POSITION;
+        // Completion hints to show in the footer area on next redraw
+        let pendingCompletions = null;
+        function dispatchEvent(event) {
+            const result = applyKeyEvent(state, event, {
+                completer: opts.completer,
+                ghostSuggester: opts.ghostSuggester
+            });
+            state = result.state;
+            if (result.sideEffect === 'clear-screen') {
+                out.write('\x1b[2J\x1b[H');
+            }
+            if (result.sideEffect === 'show-completions' && result.completionsToShow) {
+                pendingCompletions = result.completionsToShow;
+            }
+            redraw();
+            if (result.output) {
+                cleanup();
+                resolve(result.output);
+            }
+        }
+        function redraw() {
+            if (state.mode === 'reverse-search') {
+                framePos = EMPTY_FRAME_POSITION;
+                pendingCompletions = null;
+                out.write(renderSearch(state, opts.prompt));
+            }
+            else {
+                const suffix = opts.promptSuffix ? opts.promptSuffix(state.line) : '';
+                const footerBase = opts.footer ? opts.footer(state.line) : '';
+                const parts = [footerBase];
+                if (pendingCompletions && pendingCompletions.length > 0) {
+                    parts.push(`\x1b[2m${pendingCompletions.slice(0, 6).join(' · ')}\x1b[0m`);
+                    pendingCompletions = null;
+                }
+                const footer = parts.filter(Boolean).join('\n');
+                const width = typeof out.columns === 'number'
+                    ? out.columns
+                    : Infinity;
+                const result = renderPromptFrame(state, opts.prompt + suffix, footer, width, framePos);
+                framePos = result.position;
+                out.write(result.frame);
+            }
+        }
+        function onData(chunk) {
+            // Defensive: if a previous consumer left stdin in string-encoding mode
+            // (e.g. setEncoding('utf8') uncleared), `chunk` is a string and
+            // `[...string]` yields chars, not bytes. Normalise to Buffer so the
+            // byte-level switch logic below stays correct.
+            const buf = typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : chunk;
+            const bytes = [...buf];
+            let i = 0;
+            while (i < bytes.length) {
+                const b = bytes[i];
+                // Escape or continuation of escape sequence
+                if (b === 0x1b || escBuf) {
+                    flushEsc();
+                    // Start new escape sequence
+                    escBuf = String.fromCharCode(b);
+                    // Collect more bytes greedily (up to 8)
+                    let j = i + 1;
+                    while (j < bytes.length && j - i < 8) {
+                        const nb = bytes[j];
+                        // Stop at printable ASCII that signals end of sequence (letters, ~)
+                        escBuf += String.fromCharCode(nb);
+                        j += 1;
+                        if (nb >= 0x40 &&
+                            nb <= 0x7e // final byte of CSI
+                        ) {
+                            // Don't break on '[' (0x5B) — it introduces CSI sequences,
+                            // so there must be at least one more byte coming.
+                            if (nb === 0x5b)
+                                continue;
+                            break;
+                        }
+                    }
+                    i = j;
+                    // Dispatch immediately if we have a complete sequence
+                    if (escBuf.length > 1) {
+                        const seq = escBuf;
+                        escBuf = '';
+                        dispatchEscSequence(seq);
+                    }
+                    else {
+                        // Wait a moment for follow-up bytes (Esc alone vs. Esc[...)
+                        escTimer = setTimeout(() => {
+                            const s = escBuf;
+                            escBuf = '';
+                            dispatchEscSequence(s || '\x1b');
+                        }, 10);
+                    }
+                    continue;
+                }
+                // Control codes
+                if (b === 0x03) {
+                    dispatchEvent({ kind: 'ctrl-c' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x04) {
+                    dispatchEvent({ kind: 'ctrl-d' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x01) {
+                    dispatchEvent({ kind: 'home' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x05) {
+                    dispatchEvent({ kind: 'end' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x06) {
+                    dispatchEvent({ kind: 'ctrl-f' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x07) {
+                    i++;
+                    continue;
+                } // bell, ignore
+                if (b === 0x08 || b === 0x7f) {
+                    dispatchEvent({ kind: 'backspace' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x09) {
+                    dispatchEvent({ kind: 'tab' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x0a || b === 0x0d) {
+                    dispatchEvent({ kind: 'enter' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x0b) {
+                    dispatchEvent({ kind: 'ctrl-k' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x0c) {
+                    dispatchEvent({ kind: 'ctrl-l' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x12) {
+                    dispatchEvent({ kind: 'ctrl-r' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x15) {
+                    dispatchEvent({ kind: 'ctrl-u' });
+                    i++;
+                    continue;
+                }
+                if (b === 0x17) {
+                    dispatchEvent({ kind: 'ctrl-w' });
+                    i++;
+                    continue;
+                }
+                // Printable ASCII or UTF-8 multi-byte: batch until next control
+                let printable = '';
+                while (i < bytes.length) {
+                    const cb = bytes[i];
+                    if (cb < 0x20 || cb === 0x7f)
+                        break;
+                    if (cb === 0x1b)
+                        break;
+                    // UTF-8 multi-byte: pass through
+                    printable += String.fromCharCode(cb);
+                    i++;
+                }
+                if (printable) {
+                    dispatchEvent({ kind: 'char', data: printable });
+                }
+            }
+        }
+        function cleanup() {
+            inp.removeListener('data', onData);
+            inp.pause();
+            if (escTimer)
+                clearTimeout(escTimer);
+            if (framePos.totalRows > 0) {
+                // Wipe the whole frame, re-print the prompt line without footer or
+                // ghost text so the submitted input stays visible in the scrollback,
+                // and park the cursor on the row immediately below.
+                const suffix = opts.promptSuffix ? opts.promptSuffix(state.line) : '';
+                let seq = '\r';
+                if (framePos.cursorRow > 0)
+                    seq += `\x1b[${framePos.cursorRow}A`;
+                seq += '\x1b[J';
+                seq += opts.prompt + suffix + state.line + '\r\n';
+                out.write(seq);
+            }
+            else {
+                out.write('\n');
+            }
+            framePos = EMPTY_FRAME_POSITION;
+            if (inp.setRawMode) {
+                try {
+                    inp.setRawMode(false);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        // Enter raw mode
+        if (inp.setRawMode) {
+            try {
+                inp.setRawMode(true);
+            }
+            catch {
+                /* ignore if not a TTY */
+            }
+        }
+        inp.resume();
+        inp.on('data', onData);
+    });
+}
+//# sourceMappingURL=prompter.js.map