@microsoft/inshellisense 0.0.1-rc.3 → 0.0.1-rc.5

package/README.md

@@ -1,13 +1,15 @@
 # inshellisense
 
-`inshellisense` provides IDE style autocomplete for shells. It's a terminal native runtime for [autocomplete](https://github.com/withfig/autocomplete) which has support for 600+ command line tools. `inshellisense` supports Windows, Linux, & MacOS.
+`inshellisense` provides IDE style autocomplete for shells. It's a terminal native runtime for [autocomplete](https://github.com/withfig/autocomplete) which has support for 600+ command line tools. `inshellisense` supports Windows, Linux, & macOS.
 
 <p align="center"><img alt="demo of inshellisense working" src="/docs/demo.gif" height="450px"/></p>
 
 ## Getting Started
 
 ### Requirements
+
 - `node >= 16.x`
+- node-gyp dependencies installed for your platform (see [node-gyp](https://github.com/nodejs/node-gyp) for more details)
 
 ### Installation
 
@@ -17,13 +19,7 @@ npm install -g @microsoft/inshellisense
 
 ### Quickstart
 
-After completing the installation, you can already run `inshellisense --shell <shell>` to start the autocomplete session for your desired shell. Additionally, you can bind `inshellisense` to a keybinding of `CTRL+a` by running the below command. This brings the added advantages of automatically starting the autocomplete session with your current shell and injecting any accepted command into your shell's history.
-
-```shell
-inshellisense bind
-```
-
-Additionally, inshellisense is also aliased under `is` after install for convenience.
+After completing the installation, you can run `is` to start the autocomplete session for your desired shell. Additionally, inshellisense is also aliased under `inshellisense` after installation.
 
 ## Integrations
 

package/build/commands/root.js

@@ -1,40 +1,21 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import { render } from "../ui/ui-root.js";
-import { executeShellCommandTTY } from "../runtime/utils.js";
-import { saveCommand, loadCommand } from "../utils/cache.js";
-import { supportedShells as shells } from "../utils/bindings.js";
+import { Shell, supportedShells as shells, setupZshDotfiles } from "../utils/shell.js";
+import { inferShell } from "../utils/shell.js";
+import { loadConfig } from "../utils/config.js";
 export const supportedShells = shells.join(", ");
-export const action = async (options) => {
-    if (options.history) {
-        process.stdout.write(await loadCommand());
-        process.exit(0);
+export const action = (program) => async (options) => {
+    await loadConfig(program);
+    const shell = options.shell ?? (await inferShell());
+    if (shell == null) {
+        program.error(`Unable to identify shell, use the -s/--shell option to provide your shell`, { exitCode: 1 });
     }
-    const shell = options.shell ?? "";
     if (!shells.map((s) => s.valueOf()).includes(shell)) {
-        console.error(`Unsupported shell: '${shell}', supported shells: ${supportedShells}`);
-        process.exit(1);
+        program.error(`Unsupported shell: '${shell}', supported shells: ${supportedShells}`, { exitCode: 1 });
     }
-    let executed = false;
-    const commands = [];
-    let result = { code: 0 };
-    let startingCommand = options.command;
-    while (options.duration === "session" || !executed) {
-        const commandToExecute = await render(startingCommand);
-        if (commandToExecute == null || commandToExecute.trim().toLowerCase() == "exit" || commandToExecute.trim().toLowerCase() == "logout") {
-            result = { code: 0 };
-            break;
-        }
-        commands.push(commandToExecute);
-        result = await executeShellCommandTTY(shell, commandToExecute);
-        executed = true;
-        startingCommand = undefined;
-    }
-    await saveCommand(commands);
-    if (result.code) {
-        process.exit(result.code);
-    }
-    else {
-        process.exit(0);
+    if (shell == Shell.Zsh) {
+        await setupZshDotfiles();
     }
+    await render(shell);
 };

package/build/commands/uninstall.js

@@ -6,6 +6,6 @@ const action = async () => {
     await render();
 };
 const cmd = new Command("uninstall");
-cmd.description(`removes all bindings and configuration for inshellisense`);
+cmd.description(`removes all configuration for inshellisense`);
 cmd.action(action);
 export default cmd;

package/build/index.js

@@ -3,7 +3,6 @@
 // Licensed under the MIT License.
 /* eslint-disable header/header */
 import { Command } from "commander";
-import bind from "./commands/bind.js";
 import uninstall from "./commands/uninstall.js";
 import { action, supportedShells } from "./commands/root.js";
 import { getVersion } from "./utils/version.js";
@@ -12,11 +11,8 @@ program
     .name("inshellisense")
     .description("IDE style command line auto complete")
     .version(await getVersion(), "-v, --version", "output the current version")
+    .action(action(program))
     .option("-s, --shell <shell>", `shell to use for command execution, supported shells: ${supportedShells}`)
-    .option("-c, --command <commmand>", "command to use as initial input")
-    .option("--history", "get the last command execute")
-    .option("-d, --duration <duration>", "duration of the autocomplete session, supported durations: single, session", "session")
-    .action(action);
-program.addCommand(bind);
+    .showHelpAfterError("(add --help for additional information)");
 program.addCommand(uninstall);
 program.parse();

package/build/isterm/commandManager.js

@@ -0,0 +1,212 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import os from "node:os";
+import { Shell } from "../utils/shell.js";
+import log from "../utils/log.js";
+import { getConfig } from "../utils/config.js";
+const maxPromptPollDistance = 10;
+export class CommandManager {
+    #activeCommand;
+    #previousCommandLines;
+    #terminal;
+    #shell;
+    #supportsProperOscPlacements = os.platform() !== "win32";
+    constructor(terminal, shell) {
+        this.#terminal = terminal;
+        this.#shell = shell;
+        this.#activeCommand = {};
+        this.#previousCommandLines = new Set();
+        if (this.#supportsProperOscPlacements) {
+            this.#terminal.parser.registerCsiHandler({ final: "J" }, (params) => {
+                if (params.at(0) == 3 || params.at(0) == 2) {
+                    this.handleClear();
+                }
+                return false;
+            });
+        }
+    }
+    handlePromptStart() {
+        this.#activeCommand = { promptStartMarker: this.#terminal.registerMarker(0), hasOutput: false, cursorTerminated: false };
+    }
+    handlePromptEnd() {
+        this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(0);
+        if (this.#activeCommand.promptEndMarker?.line === this.#terminal.buffer.active.cursorY) {
+            this.#activeCommand.promptEndX = this.#terminal.buffer.active.cursorX;
+        }
+        if (this.#supportsProperOscPlacements) {
+            this.#activeCommand.promptText = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker?.line ?? 0)?.translateToString(true);
+            this.#previousCommandLines.add(this.#activeCommand.promptEndMarker?.line ?? -1);
+        }
+    }
+    handleClear() {
+        this.handlePromptStart();
+        this.#previousCommandLines = new Set();
+    }
+    _getWindowsPrompt(y) {
+        const line = this.#terminal.buffer.active.getLine(y);
+        if (!line) {
+            return;
+        }
+        const lineText = line.translateToString(true);
+        if (!lineText) {
+            return;
+        }
+        // User defined prompt
+        const inshellisenseConfig = getConfig();
+        if (this.#shell == Shell.Bash) {
+            if (inshellisenseConfig.promptRegex?.bash != null) {
+                const customBashPrompt = lineText.match(new RegExp(inshellisenseConfig.promptRegex?.bash.regex))?.groups?.prompt;
+                const adjustedPrompt = this._adjustPrompt(customBashPrompt, lineText, inshellisenseConfig.promptRegex?.bash.postfix);
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+            const bashPrompt = lineText.match(/^(?<prompt>.*\$\s?)/)?.groups?.prompt;
+            if (bashPrompt) {
+                const adjustedPrompt = this._adjustPrompt(bashPrompt, lineText, "$");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Powershell || this.#shell == Shell.Pwsh) {
+            if (inshellisenseConfig.promptRegex?.pwsh != null && this.#shell == Shell.Pwsh) {
+                const customPwshPrompt = lineText.match(new RegExp(inshellisenseConfig.promptRegex?.pwsh.regex))?.groups?.prompt;
+                const adjustedPrompt = this._adjustPrompt(customPwshPrompt, lineText, inshellisenseConfig.promptRegex?.pwsh.postfix);
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+            if (inshellisenseConfig.promptRegex?.powershell != null && this.#shell == Shell.Powershell) {
+                const customPowershellPrompt = lineText.match(new RegExp(inshellisenseConfig.promptRegex?.powershell.regex))?.groups?.prompt;
+                const adjustedPrompt = this._adjustPrompt(customPowershellPrompt, lineText, inshellisenseConfig.promptRegex?.powershell.postfix);
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+            const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
+            if (pwshPrompt) {
+                const adjustedPrompt = this._adjustPrompt(pwshPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Cmd) {
+            return lineText.match(/^(?<prompt>(\(.+\)\s)?(?:[A-Z]:\\.*>))/)?.groups?.prompt;
+        }
+        // Custom prompts like starship end in the common \u276f character
+        const customPrompt = lineText.match(/.*\u276f(?=[^\u276f]*$)/g)?.[0];
+        if (customPrompt) {
+            const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, "\u276f");
+            if (adjustedPrompt) {
+                return adjustedPrompt;
+            }
+        }
+    }
+    _adjustPrompt(prompt, lineText, char) {
+        if (!prompt) {
+            return;
+        }
+        // Conpty may not 'render' the space at the end of the prompt
+        if (lineText === prompt && prompt.endsWith(char)) {
+            prompt += " ";
+        }
+        return prompt;
+    }
+    _isSuggestion(cell) {
+        const color = cell?.getFgColor();
+        const dullColor = color == 8 || (color ?? 0) > 235;
+        if (this.#shell == Shell.Powershell) {
+            return false;
+        }
+        else if (this.#shell == Shell.Pwsh) {
+            return (color ?? 0) > 235;
+        }
+        return dullColor;
+    }
+    getState() {
+        return {
+            promptText: this.#activeCommand.promptText,
+            commandText: this.#activeCommand.commandText,
+            suggestionsText: this.#activeCommand.suggestionsText,
+            hasOutput: this.#activeCommand.hasOutput,
+            cursorTerminated: this.#activeCommand.cursorTerminated,
+        };
+    }
+    termSync() {
+        if (this.#activeCommand.promptEndMarker == null || this.#activeCommand.promptStartMarker == null) {
+            return;
+        }
+        const promptEndMarker = this.#activeCommand.promptEndMarker;
+        const promptStartMarker = this.#activeCommand.promptStartMarker;
+        const globalCursorPosition = this.#terminal.buffer.active.baseY + this.#terminal.buffer.active.cursorY;
+        const withinPollDistance = globalCursorPosition < this.#activeCommand.promptEndMarker.line + 5;
+        if (globalCursorPosition < promptStartMarker.line) {
+            this.handleClear();
+        }
+        // if we haven't fond the prompt yet, poll over the next 5 lines searching for it
+        if (this.#activeCommand.promptText == null && withinPollDistance) {
+            for (let i = globalCursorPosition; i < promptEndMarker.line + maxPromptPollDistance; i++) {
+                if (this.#previousCommandLines.has(i))
+                    continue;
+                const promptResult = this._getWindowsPrompt(i);
+                if (promptResult != null) {
+                    this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(i - globalCursorPosition);
+                    this.#activeCommand.promptEndX = promptResult.length;
+                    this.#activeCommand.promptText = promptResult;
+                    this.#previousCommandLines.add(i);
+                }
+            }
+        }
+        // if the prompt is set, now parse out the values from the terminal
+        if (this.#activeCommand.promptText != null) {
+            let lineY = promptEndMarker.line;
+            let line = this.#terminal.buffer.active.getLine(promptEndMarker.line);
+            let command = "";
+            let suggestions = "";
+            for (;;) {
+                for (let i = lineY == promptEndMarker.line ? this.#activeCommand.promptText.length : 0; i < this.#terminal.cols; i++) {
+                    const cell = line?.getCell(i);
+                    if (cell == null)
+                        continue;
+                    if (!this._isSuggestion(cell) && suggestions.length == 0) {
+                        command += cell.getChars();
+                    }
+                    else {
+                        suggestions += cell.getChars();
+                    }
+                }
+                lineY += 1;
+                line = this.#terminal.buffer.active.getLine(lineY);
+                if (!line?.isWrapped) {
+                    break;
+                }
+            }
+            const cursorAtEndOfInput = (this.#activeCommand.promptText.length + command.trim().length) % this.#terminal.cols <= this.#terminal.buffer.active.cursorX;
+            let hasOutput = false;
+            let cell = undefined;
+            for (let i = 0; i < this.#terminal.cols; i++) {
+                cell = line?.getCell(i, cell);
+                if (cell == null)
+                    continue;
+                hasOutput = cell.getChars() != "";
+                if (hasOutput) {
+                    break;
+                }
+            }
+            const commandPostfix = this.#activeCommand.promptText.length + command.trim().length < this.#terminal.buffer.active.cursorX ? " " : "";
+            this.#activeCommand.persistentOutput = this.#activeCommand.hasOutput && hasOutput;
+            this.#activeCommand.hasOutput = hasOutput;
+            this.#activeCommand.suggestionsText = suggestions.trim();
+            this.#activeCommand.commandText = command.trim() + commandPostfix;
+            this.#activeCommand.cursorTerminated = cursorAtEndOfInput;
+        }
+        log.debug({
+            msg: "cmd manager state",
+            ...this.#activeCommand,
+            promptEndMarker: this.#activeCommand.promptEndMarker?.line,
+            promptStartMarker: this.#activeCommand.promptStartMarker?.line,
+        });
+    }
+}

package/build/isterm/index.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { spawn } from "./pty.js";
+export default { spawn };

package/build/isterm/pty.js

@@ -0,0 +1,217 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { EventEmitter } from "node:events";
+import process from "node:process";
+import os from "node:os";
+import path from "node:path";
+import url from "node:url";
+import pty from "node-pty";
+import { Shell, userZdotdir, zdotdir } from "../utils/shell.js";
+import { IsTermOscPs, IstermOscPt, IstermPromptStart, IstermPromptEnd } from "../utils/ansi.js";
+import xterm from "xterm-headless";
+import { CommandManager } from "./commandManager.js";
+import log from "../utils/log.js";
+import { gitBashPath } from "../utils/shell.js";
+import ansi from "ansi-escapes";
+import styles from "ansi-styles";
+const ISTermOnDataEvent = "data";
+export class ISTerm {
+    pid;
+    cols;
+    rows;
+    process;
+    handleFlowControl = false;
+    onData;
+    onExit;
+    shellBuffer;
+    #pty;
+    #ptyEmitter;
+    #term;
+    #commandManager;
+    constructor({ shell, cols, rows, env, shellTarget, shellArgs }) {
+        this.#pty = pty.spawn(shellTarget, shellArgs ?? [], {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: process.cwd(),
+            env: { ...convertToPtyEnv(shell), ...env },
+        });
+        this.pid = this.#pty.pid;
+        this.cols = this.#pty.cols;
+        this.rows = this.#pty.rows;
+        this.process = this.#pty.process;
+        this.#term = new xterm.Terminal({ allowProposedApi: true, rows, cols });
+        this.#term.parser.registerOscHandler(IsTermOscPs, (data) => this._handleIsSequence(data));
+        this.#commandManager = new CommandManager(this.#term, shell);
+        this.#ptyEmitter = new EventEmitter();
+        this.#pty.onData((data) => {
+            this.#term.write(data, () => {
+                log.debug({ msg: "parsing data", data, bytes: Uint8Array.from([...data].map((c) => c.charCodeAt(0))) });
+                this.#commandManager.termSync();
+                this.#ptyEmitter.emit(ISTermOnDataEvent, data);
+            });
+        });
+        this.onData = (listener) => {
+            this.#ptyEmitter.on(ISTermOnDataEvent, listener);
+            return {
+                dispose: () => this.#ptyEmitter.removeListener(ISTermOnDataEvent, listener),
+            };
+        };
+        this.onExit = this.#pty.onExit;
+    }
+    _handleIsSequence(data) {
+        const argsIndex = data.indexOf(";");
+        const sequence = argsIndex === -1 ? data : data.substring(0, argsIndex);
+        switch (sequence) {
+            case IstermOscPt.PromptStarted:
+                this.#commandManager.handlePromptStart();
+                break;
+            case IstermOscPt.PromptEnded:
+                this.#commandManager.handlePromptEnd();
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+    noop() {
+        this.#ptyEmitter.emit(ISTermOnDataEvent, "");
+    }
+    resize(columns, rows) {
+        this.cols = columns;
+        this.rows = rows;
+        this.#pty.resize(columns, rows);
+        this.#term.resize(columns, rows);
+    }
+    clear() {
+        this.#term.reset();
+        this.#pty.clear();
+    }
+    kill(signal) {
+        this.#pty.kill(signal);
+    }
+    pause() {
+        this.#pty.pause();
+    }
+    resume() {
+        this.#pty.resume();
+    }
+    write(data) {
+        log.debug({ msg: "reading data", data, bytes: Uint8Array.from([...data].map((c) => c.charCodeAt(0))) });
+        this.#pty.write(data);
+    }
+    getCommandState() {
+        return this.#commandManager.getState();
+    }
+    getCursorState() {
+        return {
+            onLastLine: this.#term.buffer.active.cursorY >= this.#term.rows - 2,
+            remainingLines: Math.max(this.#term.rows - 2 - this.#term.buffer.active.cursorY, 0),
+            cursorX: this.#term.buffer.active.cursorX,
+            cursorY: this.#term.buffer.active.cursorY,
+        };
+    }
+    _sameColor(baseCell, targetCell) {
+        return (baseCell?.getBgColorMode() == targetCell?.getBgColorMode() &&
+            baseCell?.getBgColor() == targetCell?.getBgColor() &&
+            baseCell?.getFgColorMode() == targetCell?.getFgColorMode() &&
+            baseCell?.getFgColor() == targetCell?.getFgColor());
+    }
+    _getAnsiColors(cell) {
+        if (cell == null)
+            return "";
+        let bgAnsi = "";
+        cell.getBgColor;
+        cell.getFgColor;
+        if (cell.isBgDefault()) {
+            bgAnsi = "\x1b[49m";
+        }
+        else if (cell.isBgPalette()) {
+            bgAnsi = `\x1b[48;5;${cell.getBgColor()}m`;
+        }
+        else {
+            bgAnsi = `\x1b[48;5;${styles.hexToAnsi256(cell.getBgColor().toString(16))}m`;
+        }
+        let fgAnsi = "";
+        if (cell.isFgDefault()) {
+            fgAnsi = "\x1b[39m";
+        }
+        else if (cell.isFgPalette()) {
+            fgAnsi = `\x1b[38;5;${cell.getFgColor()}m`;
+        }
+        else {
+            fgAnsi = `\x1b[38;5;${styles.hexToAnsi256(cell.getFgColor().toString(16))}m`;
+        }
+        return bgAnsi + fgAnsi;
+    }
+    getCells(height, direction) {
+        const currentCursorPosition = this.#term.buffer.active.cursorY + this.#term.buffer.active.baseY;
+        const writeLine = (y) => {
+            const line = this.#term.buffer.active.getLine(y);
+            const ansiLine = ["\x1b[0m"];
+            if (line == null)
+                return "";
+            let prevCell;
+            for (let x = 0; x < line.length; x++) {
+                const cell = line.getCell(x);
+                const chars = cell?.getChars() ?? "";
+                if (!this._sameColor(prevCell, cell)) {
+                    ansiLine.push(this._getAnsiColors(cell));
+                }
+                ansiLine.push(chars == "" ? " " : chars);
+                prevCell = cell;
+            }
+            return ansiLine.join("");
+        };
+        const lines = [];
+        if (direction == "above") {
+            const startCursorPosition = currentCursorPosition - 1;
+            const endCursorPosition = currentCursorPosition - 1 - height;
+            for (let y = startCursorPosition; y > endCursorPosition; y--) {
+                lines.push(writeLine(y));
+            }
+        }
+        else {
+            const startCursorPosition = currentCursorPosition + 1;
+            const endCursorPosition = currentCursorPosition + 1 + height;
+            for (let y = startCursorPosition; y < endCursorPosition; y++) {
+                lines.push(writeLine(y));
+            }
+        }
+        return lines.reverse().join(ansi.cursorNextLine);
+    }
+}
+export const spawn = async (options) => {
+    const { shellTarget, shellArgs } = await convertToPtyTarget(options.shell);
+    return new ISTerm({ ...options, shellTarget, shellArgs });
+};
+const convertToPtyTarget = async (shell) => {
+    const platform = os.platform();
+    const shellTarget = shell == Shell.Bash && platform == "win32" ? await gitBashPath() : platform == "win32" ? `${shell}.exe` : shell;
+    const shellFolderPath = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "..", "..", "shell");
+    let shellArgs = [];
+    switch (shell) {
+        case Shell.Bash:
+            shellArgs = ["--init-file", path.join(shellFolderPath, "shellIntegration.bash")];
+            break;
+        case (Shell.Powershell, Shell.Pwsh):
+            shellArgs = ["-noexit", "-command", `try { . "${path.join(shellFolderPath, "shellIntegration.ps1")}" } catch {}`];
+            break;
+        case Shell.Fish:
+            shellArgs = ["--init-command", `. ${path.join(shellFolderPath, "shellIntegration.fish").replace(/(\s+)/g, "\\$1")}`];
+            break;
+    }
+    return { shellTarget, shellArgs };
+};
+const convertToPtyEnv = (shell) => {
+    switch (shell) {
+        case Shell.Cmd: {
+            const prompt = process.env.PROMPT ? process.env.PROMPT : "$P$G";
+            return { ...process.env, PROMPT: `${IstermPromptStart}${prompt}${IstermPromptEnd}` };
+        }
+        case Shell.Zsh: {
+            return { ...process.env, ZDOTDIR: zdotdir, USER_ZDOTDIR: userZdotdir };
+        }
+    }
+    return process.env;
+};

package/build/runtime/template.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import fsAsync from "fs/promises";
+import fsAsync from "node:fs/promises";
 import process from "node:process";
 const filepathsTemplate = async () => {
     const files = await fsAsync.readdir(process.cwd(), { withFileTypes: true });

package/build/ui/input.js

@@ -1,55 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import React, { useState, useEffect } from "react";
-import { useInput, Text } from "ink";
-import chalk from "chalk";
-const BlinkSpeed = 530;
-const CursorColor = "#FFFFFF";
-export default function Input({ value, setValue, prompt, activeSuggestion, tabCompletionDropSize, }) {
-    const [cursorLocation, setCursorLocation] = useState(value.length);
-    const [cursorBlink, setCursorBlink] = useState(true);
-    useEffect(() => {
-        setTimeout(() => {
-            setCursorBlink(!cursorBlink);
-        }, BlinkSpeed);
-    }, [cursorBlink]);
-    // TODO: arrow key navigation shortcuts (emacs & vim modes)
-    useInput((input, key) => {
-        // TODO: handle delete better on unix systems: https://github.com/vadimdemedes/ink/issues/634
-        const windows = process.platform === "win32";
-        const backspaceKey = windows ? key.backspace : key.backspace || key.delete;
-        const deleteKey = windows ? key.delete : false;
-        if (backspaceKey) {
-            setValue([...value].slice(0, Math.max(cursorLocation - 1, 0)).join("") + [...value].slice(cursorLocation).join(""));
-            setCursorLocation(Math.max(cursorLocation - 1, 0));
-        }
-        else if (deleteKey) {
-            setValue([...value].slice(0, cursorLocation).join("") + [...value].slice(Math.min(value.length, cursorLocation + 1)).join(""));
-        }
-        else if (key.leftArrow) {
-            setCursorLocation(Math.max(cursorLocation - 1, 0));
-        }
-        else if (key.rightArrow) {
-            setCursorLocation(Math.min(cursorLocation + 1, value.length));
-        }
-        else if (key.tab) {
-            if (activeSuggestion) {
-                // TOOD: support insertValue
-                const newValue = [...value].slice(0, cursorLocation - tabCompletionDropSize).join("") + activeSuggestion.name + " ";
-                setValue(newValue);
-                setCursorLocation(newValue.length);
-            }
-        }
-        else if (input) {
-            setValue([...value].slice(0, cursorLocation).join("") + input + [...value].slice(cursorLocation).join(""));
-            setCursorLocation(cursorLocation + input.length);
-        }
-    });
-    const cursoredCommand = value + " ";
-    const cursoredText = [...cursoredCommand].slice(0, cursorLocation).join("") +
-        (cursorBlink ? chalk.bgHex(CursorColor).inverse([...cursoredCommand].at(cursorLocation)) : [...cursoredCommand].at(cursorLocation)) +
-        [...cursoredCommand].slice(cursorLocation + 1).join("");
-    return (React.createElement(Text, null,
-        prompt,
-        cursoredText));
-}
+export const inputModifier = (input) => {
+    switch (input.toString()) {
+        case "\b":
+            return "\u007F"; // DEL
+    }
+    return input.toString();
+};