@edwardlee5423/magi 0.1.0-alpha.0

package/dist/tui/paste.js

@@ -0,0 +1,113 @@
+/**
+ * Bracketed paste handling for the TUI.
+ *
+ * Modern terminals send ESC[200~ ... ESC[201~ around pasted content. This
+ * lets us reliably tell typing apart from pasting:
+ *   - short single-line pastes are inserted directly into the line buffer
+ *   - long or multi-line pastes are replaced with a `[paste #N: ...]`
+ *     placeholder and the real content is stashed; on submit the caller
+ *     calls `restorePastes()` to swap the placeholder back to the real text
+ *
+ * We also intercept stdin's `data` listeners before readline sees them so
+ * we can split out paste markers without confusing readline's editor state.
+ *
+ * The TUI is the only consumer; this module is intentionally tied to the
+ * Node `readline/promises` Interface and `process.stdin`-shaped streams.
+ */
+const PASTE_START = Buffer.from("\x1b[200~");
+const PASTE_END = Buffer.from("\x1b[201~");
+export function installPasteHandler(input) {
+    const { rl, stdin, stdout } = input;
+    // Get readline's internal symbols so we can feed paste content into the
+    // line buffer (rather than submit it).
+    const rlProto = Object.getPrototypeOf(Object.getPrototypeOf(rl));
+    const kInsertString = Object.getOwnPropertySymbols(rlProto).find((s) => s.toString() === "Symbol(_insertString)");
+    // Enable bracketed paste mode.
+    stdout.write("\x1b[?2004h");
+    // Stash for paste content: the visible buffer shows "[paste #N: M lines]"
+    // but the actual content is restored when the user presses Enter.
+    const pasteStash = new Map();
+    let pasteCounter = 0;
+    let pasteBuffer = null;
+    // Intercept the data stream BEFORE readline sees it.
+    const origDataListeners = stdin.listeners("data");
+    for (const l of origDataListeners)
+        stdin.removeListener("data", l);
+    let leftover = Buffer.alloc(0);
+    const onData = (buf) => {
+        leftover = Buffer.concat([leftover, buf]);
+        while (leftover.length > 0) {
+            if (pasteBuffer !== null) {
+                const endIdx = leftover.indexOf(PASTE_END);
+                if (endIdx === -1) {
+                    pasteBuffer += leftover.toString("utf8");
+                    leftover = Buffer.alloc(0);
+                    return;
+                }
+                pasteBuffer += leftover.slice(0, endIdx).toString("utf8");
+                const completed = pasteBuffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+                pasteBuffer = null;
+                leftover = leftover.slice(endIdx + PASTE_END.length);
+                if (completed.length > 0) {
+                    const lineCount = completed.split("\n").length;
+                    if (lineCount === 1 && completed.length < 200) {
+                        // Short single-line paste — insert directly.
+                        if (kInsertString && rl[kInsertString]) {
+                            rl[kInsertString](completed);
+                        }
+                    }
+                    else {
+                        // Multi-line or long paste — show placeholder, stash real content.
+                        pasteCounter += 1;
+                        const placeholder = `[paste #${pasteCounter}: ${completed.length} chars, ${lineCount} lines]`;
+                        pasteStash.set(placeholder, completed);
+                        if (kInsertString && rl[kInsertString]) {
+                            rl[kInsertString](placeholder);
+                        }
+                    }
+                }
+                continue;
+            }
+            const startIdx = leftover.indexOf(PASTE_START);
+            if (startIdx === -1) {
+                // No paste start — pass everything to readline.
+                for (const listener of origDataListeners)
+                    listener(leftover);
+                leftover = Buffer.alloc(0);
+                return;
+            }
+            if (startIdx > 0) {
+                const before = leftover.slice(0, startIdx);
+                for (const listener of origDataListeners)
+                    listener(before);
+            }
+            pasteBuffer = "";
+            leftover = leftover.slice(startIdx + PASTE_START.length);
+        }
+    };
+    stdin.on("data", onData);
+    let disposed = false;
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        stdout.write("\x1b[?2004l");
+    };
+    process.on("exit", dispose);
+    return {
+        restorePastes(line) {
+            if (pasteStash.size === 0 || !line.includes("[paste #"))
+                return line;
+            let result = line;
+            for (const [placeholder, content] of pasteStash) {
+                if (placeholder.startsWith("[paste #")) {
+                    result = result.split(placeholder).join(content);
+                }
+            }
+            pasteStash.clear();
+            return result;
+        },
+        dispose
+    };
+}
+//# sourceMappingURL=paste.js.map

package/dist/tui/paste.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste.js","sourceRoot":"","sources":["../../src/tui/paste.ts"],"names":[],"mappings":"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"}

package/dist/tui/prompt-reader.d.ts

@@ -0,0 +1,26 @@
+export type TuiPromptAbortReason = "SIGINT" | "EOF";
+export declare class TuiPromptAbortError extends Error {
+    readonly reason: TuiPromptAbortReason;
+    constructor(reason: TuiPromptAbortReason);
+}
+export interface TuiPromptOptions {
+    input: NodeJS.ReadStream;
+    output: NodeJS.WriteStream;
+    prompt: string;
+    history?: string[];
+    initialValue?: string;
+    maxVisibleLines?: number;
+}
+export declare function readTuiPrompt(options: TuiPromptOptions): Promise<string>;
+export declare function buildPromptDisplayForTest(input: {
+    prompt: string;
+    text: string;
+    cursor: number;
+    safeColumns: number;
+    maxVisibleLines: number;
+    final?: boolean;
+}): {
+    lines: string[];
+    cursorLine: number;
+    cursorColumn: number;
+};

package/dist/tui/prompt-reader.js

@@ -0,0 +1,553 @@
+import { once } from "node:events";
+export class TuiPromptAbortError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+const DIM = "\x1b[90m";
+const RESET = "\x1b[0m";
+let graphemeSegmenter;
+export async function readTuiPrompt(options) {
+    const { input, output, prompt } = options;
+    const history = options.history ?? [];
+    const maxVisibleLines = Math.max(1, options.maxVisibleLines ?? 6);
+    let text = options.initialValue ?? "";
+    let cursor = text.length;
+    let renderedLines = 0;
+    let renderedCursorLine = 0;
+    let pending = "";
+    let pasteBuffer;
+    let pasteCounter = 0;
+    let historyIndex = history.length;
+    let draft = text;
+    const pasteStash = new Map();
+    const readlineListeners = input.rawListeners("data").slice();
+    for (const listener of readlineListeners) {
+        input.removeListener("data", listener);
+    }
+    const wasRaw = input.isRaw;
+    if (input.isTTY) {
+        input.setRawMode(true);
+    }
+    input.resume();
+    output.write("\x1b[?2004h");
+    let settled = false;
+    let resolvePrompt;
+    let rejectPrompt;
+    const cleanup = () => {
+        input.removeListener("data", onData);
+        output.write("\x1b[?2004l");
+        if (input.isTTY) {
+            input.setRawMode(Boolean(wasRaw));
+        }
+        for (const listener of readlineListeners) {
+            input.on("data", listener);
+        }
+    };
+    const finish = (value) => {
+        if (settled)
+            return;
+        settled = true;
+        render(true);
+        output.write("\n");
+        cleanup();
+        resolvePrompt(restorePastes(value, pasteStash));
+    };
+    const abort = (reason) => {
+        if (settled)
+            return;
+        settled = true;
+        render(true);
+        output.write("\n");
+        cleanup();
+        rejectPrompt(new TuiPromptAbortError(reason));
+    };
+    const insert = (value) => {
+        if (!value)
+            return;
+        text = text.slice(0, cursor) + value + text.slice(cursor);
+        cursor += value.length;
+        historyIndex = history.length;
+    };
+    const backspace = () => {
+        if (cursor <= 0)
+            return;
+        const prev = previousOffset(text, cursor);
+        text = text.slice(0, prev) + text.slice(cursor);
+        cursor = prev;
+        historyIndex = history.length;
+    };
+    const del = () => {
+        if (cursor >= text.length)
+            return;
+        const next = nextOffset(text, cursor);
+        text = text.slice(0, cursor) + text.slice(next);
+        historyIndex = history.length;
+    };
+    const moveHistory = (direction) => {
+        if (history.length === 0)
+            return;
+        if (historyIndex === history.length) {
+            draft = text;
+        }
+        const next = historyIndex + direction;
+        if (next < 0)
+            return;
+        if (next >= history.length) {
+            historyIndex = history.length;
+            text = draft;
+            cursor = text.length;
+            return;
+        }
+        historyIndex = next;
+        text = history[historyIndex] ?? "";
+        cursor = text.length;
+    };
+    const moveVerticalOrHistory = (direction) => {
+        const lines = splitLogicalLines(text);
+        const pos = positionForOffset(lines, cursor);
+        const targetLine = pos.line + direction;
+        if (targetLine >= 0 && targetLine < lines.length) {
+            const target = lines[targetLine];
+            cursor = Math.min(target.start + pos.column, target.end);
+            return;
+        }
+        moveHistory(direction);
+    };
+    const submitOrNewline = () => {
+        if (cursor > 0 && text[cursor - 1] === "\\") {
+            text = text.slice(0, cursor - 1) + "\n" + text.slice(cursor);
+            return;
+        }
+        finish(text);
+    };
+    const insertPaste = (raw) => {
+        const normalized = raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        if (!normalized)
+            return;
+        const lineCount = normalized.split("\n").length;
+        if (lineCount === 1 && normalized.length < 200) {
+            insert(normalized);
+            return;
+        }
+        pasteCounter += 1;
+        const placeholder = `[paste #${pasteCounter}: ${normalized.length} chars, ${lineCount} lines]`;
+        pasteStash.set(placeholder, normalized);
+        insert(placeholder);
+    };
+    const processText = (chunk) => {
+        let i = 0;
+        while (i < chunk.length) {
+            if (chunk.startsWith("\x1b[13;2u", i) || chunk.startsWith("\x1b[13;3u", i)) {
+                insert("\n");
+                i += 7;
+                continue;
+            }
+            if (chunk.startsWith("\x1b\r", i) || chunk.startsWith("\x1b\n", i)) {
+                insert("\n");
+                i += 2;
+                continue;
+            }
+            if (chunk.startsWith("\x1b[A", i)) {
+                moveVerticalOrHistory(-1);
+                i += 3;
+                continue;
+            }
+            if (chunk.startsWith("\x1b[B", i)) {
+                moveVerticalOrHistory(1);
+                i += 3;
+                continue;
+            }
+            if (chunk.startsWith("\x1b[C", i)) {
+                cursor = nextOffset(text, cursor);
+                i += 3;
+                continue;
+            }
+            if (chunk.startsWith("\x1b[D", i)) {
+                cursor = previousOffset(text, cursor);
+                i += 3;
+                continue;
+            }
+            if (chunk.startsWith("\x1b[H", i) || chunk.startsWith("\x1b[1~", i)) {
+                cursor = lineStartForOffset(text, cursor);
+                i += chunk.startsWith("\x1b[H", i) ? 3 : 4;
+                continue;
+            }
+            if (chunk.startsWith("\x1b[F", i) || chunk.startsWith("\x1b[4~", i)) {
+                cursor = lineEndForOffset(text, cursor);
+                i += chunk.startsWith("\x1b[F", i) ? 3 : 4;
+                continue;
+            }
+            if (chunk.startsWith("\x1b[3~", i)) {
+                del();
+                i += 4;
+                continue;
+            }
+            if (chunk[i] === "\x1b") {
+                const match = chunk.slice(i).match(/^\x1b\[[0-9;?]*[~A-Za-z]/);
+                i += match ? match[0].length : 1;
+                continue;
+            }
+            const ch = chunk[i];
+            if (ch === "\x03") {
+                if (text.length > 0) {
+                    text = "";
+                    cursor = 0;
+                }
+                else {
+                    abort("SIGINT");
+                    return;
+                }
+            }
+            else if (ch === "\x04") {
+                if (text.length === 0) {
+                    abort("EOF");
+                    return;
+                }
+            }
+            else if (ch === "\r" || ch === "\n") {
+                submitOrNewline();
+                return;
+            }
+            else if (ch === "\x7f" || ch === "\b") {
+                backspace();
+            }
+            else if (ch >= " " || ch === "\t") {
+                const grapheme = firstGrapheme(chunk.slice(i));
+                insert(grapheme.segment);
+                i += grapheme.segment.length - 1;
+            }
+            i += 1;
+        }
+    };
+    const processPending = () => {
+        while (pending.length > 0 && !settled) {
+            if (pasteBuffer !== undefined) {
+                const end = pending.indexOf(PASTE_END);
+                if (end === -1) {
+                    pasteBuffer += pending;
+                    pending = "";
+                    break;
+                }
+                pasteBuffer += pending.slice(0, end);
+                pending = pending.slice(end + PASTE_END.length);
+                insertPaste(pasteBuffer);
+                pasteBuffer = undefined;
+                continue;
+            }
+            const start = pending.indexOf(PASTE_START);
+            if (start === -1) {
+                const chunk = pending;
+                pending = "";
+                processText(chunk);
+                break;
+            }
+            if (start > 0) {
+                const before = pending.slice(0, start);
+                pending = pending.slice(start);
+                processText(before);
+                continue;
+            }
+            pasteBuffer = "";
+            pending = pending.slice(PASTE_START.length);
+        }
+    };
+    function onData(buffer) {
+        pending += buffer.toString("utf8");
+        processPending();
+        if (!settled)
+            render(false);
+    }
+    function render(final) {
+        const terminalColumns = output.columns || 80;
+        const safeColumns = safePromptColumns(terminalColumns);
+        const display = buildDisplay({
+            prompt,
+            text,
+            cursor,
+            safeColumns,
+            maxVisibleLines,
+            final
+        });
+        if (renderedLines > 0) {
+            if (renderedCursorLine > 0) {
+                output.write(`\x1b[${renderedCursorLine}A`);
+            }
+            output.write("\r\x1b[J");
+        }
+        output.write(display.lines.join("\n"));
+        renderedLines = display.lines.length;
+        if (final) {
+            renderedCursorLine = renderedLines - 1;
+            return;
+        }
+        const up = display.lines.length - 1 - display.cursorLine;
+        if (up > 0)
+            output.write(`\x1b[${up}A`);
+        output.write("\r");
+        if (display.cursorColumn > 0)
+            output.write(`\x1b[${display.cursorColumn}C`);
+        renderedCursorLine = display.cursorLine;
+    }
+    const result = new Promise((resolve, reject) => {
+        resolvePrompt = resolve;
+        rejectPrompt = reject;
+    });
+    input.on("data", onData);
+    render(false);
+    await Promise.race([result, once(input, "error").then(([error]) => Promise.reject(error))]);
+    return result;
+}
+function restorePastes(value, pasteStash) {
+    let result = value;
+    for (const [placeholder, content] of pasteStash) {
+        result = result.split(placeholder).join(content);
+    }
+    return result;
+}
+export function buildPromptDisplayForTest(input) {
+    return buildDisplay({ ...input, final: input.final ?? false });
+}
+function buildDisplay(input) {
+    const logical = splitLogicalLines(input.text);
+    const pos = positionForOffset(logical, input.cursor);
+    const half = Math.floor(input.maxVisibleLines / 2);
+    let first = Math.max(0, pos.line - half);
+    const last = Math.min(logical.length, first + input.maxVisibleLines);
+    first = Math.max(0, last - input.maxVisibleLines);
+    const visible = logical.slice(first, last);
+    const lines = [];
+    let cursorLine = 0;
+    let cursorColumn = 0;
+    for (let index = 0; index < visible.length; index++) {
+        const sourceLine = first + index;
+        const logicalLine = visible[index];
+        const prefix = sourceLine === 0 ? input.prompt : `${DIM}... ${RESET}`;
+        const contentWidth = Math.max(8, input.safeColumns - visibleWidth(prefix));
+        const isCursorLine = sourceLine === pos.line;
+        const cursorCell = visibleWidth(logicalLine.text.slice(0, pos.column));
+        const windowStart = isCursorLine
+            ? windowStartForCursor(cursorCell, contentWidth, visibleWidth(logicalLine.text))
+            : 0;
+        const leftMarker = windowStart > 0 ? "…" : "";
+        const rightMarker = windowStart + contentWidth < visibleWidth(logicalLine.text) ? "…" : "";
+        const markerWidth = visibleWidth(leftMarker) + visibleWidth(rightMarker);
+        const shown = `${leftMarker}${sliceCells(logicalLine.text, windowStart, Math.max(0, contentWidth - markerWidth))}${rightMarker}`;
+        const line = clipToColumns(prefix + shown, input.safeColumns);
+        lines.push(line);
+        if (isCursorLine) {
+            cursorLine = index;
+            cursorColumn = Math.min(Math.max(0, input.safeColumns - 2), visibleWidth(prefix) + Math.max(0, cursorCell - windowStart) + visibleWidth(leftMarker));
+        }
+    }
+    if (lines.length === 0) {
+        lines.push(input.prompt);
+    }
+    if (logical.length > input.maxVisibleLines && !input.final) {
+        lines.push(`${DIM}[${logical.length} lines, use Option+Enter or backslash+Enter for newline]${RESET}`);
+    }
+    return { lines, cursorLine, cursorColumn };
+}
+function splitLogicalLines(text) {
+    const lines = [];
+    let start = 0;
+    for (let index = 0; index <= text.length; index++) {
+        if (index === text.length || text[index] === "\n") {
+            lines.push({ text: text.slice(start, index), start, end: index });
+            start = index + 1;
+        }
+    }
+    return lines.length > 0 ? lines : [{ text: "", start: 0, end: 0 }];
+}
+function positionForOffset(lines, offset) {
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (offset >= line.start && offset <= line.end) {
+            return { line: index, column: offset - line.start };
+        }
+    }
+    const last = lines[lines.length - 1];
+    return { line: lines.length - 1, column: last.text.length };
+}
+function windowStartForCursor(column, width, lineLength) {
+    if (lineLength <= width)
+        return 0;
+    const margin = Math.max(2, Math.floor(width / 4));
+    if (column < width - margin)
+        return 0;
+    return Math.min(lineLength - width, column - width + margin);
+}
+function previousOffset(text, offset) {
+    if (offset <= 0)
+        return 0;
+    let previous = 0;
+    for (const grapheme of segmentGraphemes(text)) {
+        if (grapheme.index >= offset) {
+            return previous;
+        }
+        previous = grapheme.index;
+    }
+    return previous;
+}
+function nextOffset(text, offset) {
+    if (offset >= text.length)
+        return text.length;
+    for (const grapheme of segmentGraphemes(text)) {
+        if (grapheme.index > offset) {
+            return grapheme.index;
+        }
+    }
+    return text.length;
+}
+function lineStartForOffset(text, offset) {
+    const prev = text.lastIndexOf("\n", Math.max(0, offset - 1));
+    return prev === -1 ? 0 : prev + 1;
+}
+function lineEndForOffset(text, offset) {
+    const next = text.indexOf("\n", offset);
+    return next === -1 ? text.length : next;
+}
+function clipToColumns(text, columns) {
+    let result = "";
+    let width = 0;
+    let ansi = false;
+    for (const ch of Array.from(text)) {
+        if (ch === "\x1b")
+            ansi = true;
+        result += ch;
+        if (ansi) {
+            if (ch === "m")
+                ansi = false;
+            continue;
+        }
+        const next = width + charWidth(ch);
+        if (next > columns) {
+            return result.slice(0, -ch.length) + RESET;
+        }
+        width = next;
+        if (width >= columns) {
+            return result + RESET;
+        }
+    }
+    return result;
+}
+function visibleWidth(text) {
+    return segmentGraphemes(stripAnsi(text)).reduce((sum, grapheme) => sum + grapheme.width, 0);
+}
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;?]*m/g, "");
+}
+function charWidth(ch) {
+    if (!ch)
+        return 0;
+    let width = 0;
+    for (const grapheme of segmentGraphemes(ch)) {
+        width += grapheme.width;
+    }
+    return width;
+}
+function sliceCells(text, startCell, width) {
+    let result = "";
+    let cell = 0;
+    for (const grapheme of segmentGraphemes(text)) {
+        const next = cell + grapheme.width;
+        if (next > startCell && cell < startCell + width) {
+            result += grapheme.segment;
+        }
+        cell = next;
+        if (cell >= startCell + width)
+            break;
+    }
+    return result;
+}
+function firstGrapheme(text) {
+    return segmentGraphemes(text)[0] ?? { segment: text[0] ?? "", index: 0, width: text[0] ? 1 : 0 };
+}
+function segmentGraphemes(text) {
+    const segmenter = getGraphemeSegmenter();
+    const segments = segmenter
+        ? [...segmenter.segment(text)].map(({ segment, index }) => ({ segment, index, width: graphemeWidth(segment) }))
+        : Array.from(text).map((segment, index) => ({ segment, index, width: graphemeWidth(segment) }));
+    return segments;
+}
+function getGraphemeSegmenter() {
+    if (graphemeSegmenter) {
+        return graphemeSegmenter;
+    }
+    if (typeof Intl.Segmenter !== "function") {
+        return undefined;
+    }
+    graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+    return graphemeSegmenter;
+}
+function graphemeWidth(grapheme) {
+    if (!grapheme)
+        return 0;
+    if (isEmojiGrapheme(grapheme)) {
+        return isSingleRegionalIndicator(grapheme) ? 1 : 2;
+    }
+    for (const char of grapheme) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint !== undefined && !isZeroWidth(codePoint)) {
+            return codePointWidth(codePoint);
+        }
+    }
+    return 0;
+}
+function codePointWidth(codePoint) {
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isWideCodePoint(codePoint) {
+    return codePoint >= 0x1100 && (codePoint <= 0x115f ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff));
+}
+function isEmojiGrapheme(grapheme) {
+    for (const char of grapheme) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint === undefined)
+            continue;
+        if ((codePoint >= 0x1f000 && codePoint <= 0x1faff)
+            || (codePoint >= 0x2600 && codePoint <= 0x27bf)
+            || codePoint === 0xfe0f
+            || codePoint === 0x200d) {
+            return true;
+        }
+    }
+    return false;
+}
+function isSingleRegionalIndicator(grapheme) {
+    const chars = Array.from(grapheme);
+    const codePoint = chars[0]?.codePointAt(0);
+    return chars.length === 1 && codePoint !== undefined && codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff;
+}
+function isZeroWidth(codePoint) {
+    return codePoint <= 0x1f
+        || (codePoint >= 0x7f && codePoint <= 0x9f)
+        || (codePoint >= 0x0300 && codePoint <= 0x036f)
+        || (codePoint >= 0x1ab0 && codePoint <= 0x1aff)
+        || (codePoint >= 0x1dc0 && codePoint <= 0x1dff)
+        || (codePoint >= 0x200b && codePoint <= 0x200f)
+        || (codePoint >= 0x202a && codePoint <= 0x202e)
+        || (codePoint >= 0x2060 && codePoint <= 0x206f)
+        || (codePoint >= 0xfe00 && codePoint <= 0xfe0f)
+        || (codePoint >= 0xfe20 && codePoint <= 0xfe2f)
+        || codePoint === 0xfeff
+        || codePoint === 0x00ad;
+}
+function safePromptColumns(terminalColumns) {
+    return Math.max(20, terminalColumns - 6);
+}
+//# sourceMappingURL=prompt-reader.js.map