typescript-virtual-container 1.5.6 → 1.5.8

package/dist/commands/registry.js

@@ -255,7 +255,12 @@ export function registerCommand(module) {
         throw new Error("Command names must be non-empty and contain no spaces");
     }
     customCommands.push(normalized);
-    buildCache();
+    // Incremental insert — avoids full Map rebuild for every registerCommand call
+    commandRegistry.set(normalized.name, normalized);
+    for (const alias of normalized.aliases ?? [])
+        commandRegistry.set(alias, normalized);
+    // Invalidate sorted names cache; rebuilt lazily on next getCommandNames()
+    cachedCommandNames = null;
 }
 export function createCustomCommand(name, params, run) {
     return { name, params, run };

package/dist/commands/rm.d.ts

@@ -2,6 +2,6 @@ import type { ShellModule } from "../types/commands";
 /**
  * Remove files or directories from the filesystem.
  * @category files
- * @params ["[-r|-rf] <path>"]
+ * @params ["[-r|-rf|-f] <path>"]
  */
 export declare const rmCommand: ShellModule;

package/dist/commands/rm.js

@@ -1,36 +1,73 @@
 import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
+const FLAG_RECURSIVE = ["-r", "-R", "-rf", "-fr", "-rF", "-Fr"];
+const FLAG_FORCE = ["-f", "-rf", "-fr", "-rF", "-Fr", "--force"];
 /**
  * Remove files or directories from the filesystem.
  * @category files
- * @params ["[-r|-rf] <path>"]
+ * @params ["[-r|-rf|-f] <path>"]
  */
 export const rmCommand = {
     name: "rm",
     description: "Remove files or directories",
     category: "files",
-    params: ["[-r|-rf] <path>"],
+    params: ["[-r|-rf|-f] <path>"],
     run: ({ authUser, shell, cwd, args }) => {
         if (args.length === 0) {
             return { stderr: "rm: missing operand", exitCode: 1 };
         }
-        const recursive = ifFlag(args, ["-r", "-rf", "-fr"]);
+        const recursive = ifFlag(args, FLAG_RECURSIVE);
+        const force = ifFlag(args, FLAG_FORCE);
+        const allFlags = [...FLAG_RECURSIVE, ...FLAG_FORCE, "--force"];
         const targets = [];
         for (let index = 0;; index += 1) {
-            const target = getArg(args, index, { flags: ["-r", "-rf", "-fr"] });
-            if (!target) {
+            const target = getArg(args, index, { flags: allFlags });
+            if (!target)
                 break;
-            }
             targets.push(target);
         }
         if (targets.length === 0) {
             return { stderr: "rm: missing operand", exitCode: 1 };
         }
-        for (const target of targets) {
-            const resolvedTarget = resolvePath(cwd, target);
-            assertPathAccess(authUser, resolvedTarget, "rm");
-            shell.vfs.remove(resolvedTarget, { recursive });
+        const resolved = targets.map((t) => resolvePath(cwd, t));
+        for (const r of resolved)
+            assertPathAccess(authUser, r, "rm");
+        for (const r of resolved) {
+            if (!shell.vfs.exists(r)) {
+                if (force)
+                    continue;
+                return { stderr: `rm: cannot remove '${r}': No such file or directory`, exitCode: 1 };
+            }
         }
-        return { exitCode: 0 };
+        const doRemove = (sh) => {
+            for (const r of resolved)
+                if (sh.vfs.exists(r))
+                    sh.vfs.remove(r, { recursive });
+            return { exitCode: 0 };
+        };
+        if (force)
+            return doRemove(shell);
+        const label = targets.length === 1 ? `'${targets[0]}'` : `${targets.length} items`;
+        const prompt = recursive
+            ? `rm: remove ${label} recursively? [y/N] `
+            : `rm: remove ${label}? [y/N] `;
+        return {
+            sudoChallenge: {
+                username: authUser,
+                targetUser: authUser,
+                commandLine: null,
+                loginShell: false,
+                prompt,
+                mode: "confirm",
+                onPassword: async (input, sh) => {
+                    const answer = input.trim().toLowerCase();
+                    if (answer !== "y" && answer !== "yes") {
+                        return { result: { stdout: "rm: cancelled\n", exitCode: 1 } };
+                    }
+                    return { result: doRemove(sh) };
+                },
+            },
+            exitCode: 0,
+        };
     },
 };

package/dist/commands/runtime.d.ts

@@ -2,6 +2,11 @@ import type { VirtualShell } from "../VirtualShell";
 import type { CommandMode, CommandResult, ShellEnv } from "../types/commands";
 /** Returns the home directory path for a given user. Root lives at /root. */
 export declare function userHome(authUser: string): string;
+/**
+ * Apply a user switch: reset PS1/USER/HOME/LOGNAME in shellEnv and re-source
+ * the new user's .bashrc. Call this after setting authUser = newUser.
+ */
+export declare function applyUserSwitch(newUser: string, hostname: string, cwd: string, shellEnv: ShellEnv, shell: VirtualShell): Promise<void>;
 export declare function makeDefaultEnv(authUser: string, hostname: string): ShellEnv;
 export declare function runCommandDirect(name: string, args: string[], authUser: string, hostname: string, mode: CommandMode, cwd: string, shell: VirtualShell, stdin: string | undefined, env: ShellEnv): Promise<CommandResult>;
 export declare function runCommand(rawInput: string, authUser: string, hostname: string, mode: CommandMode, cwd: string, shell: VirtualShell, stdin?: string, env?: ShellEnv): Promise<CommandResult>;

package/dist/commands/runtime.js

@@ -4,10 +4,42 @@ import { parseScript } from "../VirtualShell/shellParser";
 import { expandAsync, expandBraces, expandGlob } from "../utils/expand";
 import { tokenizeCommand } from "../utils/tokenize";
 import { resolveModule } from "./registry";
+// Module-level compiled regexes — avoids recompilation on every runCommand call
+const ASSIGN_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+const RE_FOR = /\bfor\s+\w+\s+in\b/;
+const RE_WHILE = /\bwhile\s+/;
+const RE_IF = /\bif\s+/;
+const RE_FUNC_BRACE = /\w+\s*\(\s*\)\s*\{/;
+const RE_FUNC_KW = /\bfunction\s+\w+/;
+const RE_ARITH = /\(\(\s*.+\s*\)\)/;
+const RE_PIPE = /(?<![|&])[|](?![|])/;
+const RE_OPERATORS = /[><;&]|\|\|/;
 /** Returns the home directory path for a given user. Root lives at /root. */
 export function userHome(authUser) {
     return authUser === "root" ? "/root" : `/home/${authUser}`;
 }
+/**
+ * Apply a user switch: reset PS1/USER/HOME/LOGNAME in shellEnv and re-source
+ * the new user's .bashrc. Call this after setting authUser = newUser.
+ */
+export async function applyUserSwitch(newUser, hostname, cwd, shellEnv, shell) {
+    shellEnv.vars.USER = newUser;
+    shellEnv.vars.LOGNAME = newUser;
+    shellEnv.vars.HOME = userHome(newUser);
+    shellEnv.vars.PS1 = makeDefaultEnv(newUser, hostname).vars.PS1 ?? "";
+    const rcPath = `${userHome(newUser)}/.bashrc`;
+    if (!shell.vfs.exists(rcPath))
+        return;
+    for (const raw of shell.vfs.readFile(rcPath).split("\n")) {
+        const l = raw.trim();
+        if (!l || l.startsWith("#"))
+            continue;
+        try {
+            await runCommand(l, newUser, hostname, "shell", cwd, shell, undefined, shellEnv);
+        }
+        catch { /* ignore */ }
+    }
+}
 export function makeDefaultEnv(authUser, hostname) {
     return {
         vars: {
@@ -18,7 +50,9 @@ export function makeDefaultEnv(authUser, hostname) {
             SHELL: "/bin/bash",
             TERM: "xterm-256color",
             HOSTNAME: hostname,
-            PS1: "\\u@\\h:\\w\\$ ",
+            PS1: authUser === "root"
+                ? "\\[\\e[37;1m\\][\\[\\e[31;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[31;1m\\]\\$\\[\\e[0m\\] "
+                : "\\[\\e[37;1m\\][\\[\\e[35;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[0m\\]\\$ ",
             "0": "/bin/bash",
         },
         lastExitCode: 0,
@@ -43,7 +77,13 @@ function resolveVfsBinary(name, env, shell, authUser) {
             return null;
         }
     }
-    const pathDirs = (env.vars.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(":");
+    const rawPath = env.vars.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    // Cache split PATH on the env object to avoid re-splitting on every binary lookup
+    if (!env._pathDirs || env._pathRaw !== rawPath) {
+        env._pathRaw = rawPath;
+        env._pathDirs = rawPath.split(":");
+    }
+    const pathDirs = env._pathDirs;
     for (const dir of pathDirs) {
         if ((dir === "/sbin" || dir === "/usr/sbin") && authUser !== "root")
             continue;
@@ -63,6 +103,35 @@ function resolveVfsBinary(name, env, shell, authUser) {
     return null;
 }
 const MAX_CALL_DEPTH = 8;
+/** Run a VFS stub file as a command, handling `exec builtin <name>` and `sh -c` stubs. */
+async function runVfsStub(vfsBinary, cmdName, args, rawInput, authUser, hostname, mode, cwd, shell, env, stdin) {
+    const stubContent = shell.vfs.readFile(vfsBinary);
+    const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
+    if (builtinMatch) {
+        const builtinMod = resolveModule(builtinMatch[1]);
+        if (builtinMod) {
+            return builtinMod.run({
+                authUser, hostname,
+                activeSessions: shell.users.listActiveSessions(),
+                rawInput, mode, args, stdin, cwd, shell, env,
+            });
+        }
+        // Guard: missing builtin — stop here to avoid sh -c infinite loop
+        return { stderr: `${cmdName}: exec builtin '${builtinMatch[1]}' not found`, exitCode: 127 };
+    }
+    const shMod = resolveModule("sh");
+    if (shMod) {
+        return shMod.run({
+            authUser, hostname,
+            activeSessions: shell.users.listActiveSessions(),
+            rawInput: `sh -c ${JSON.stringify(stubContent)}`,
+            mode,
+            args: ["-c", stubContent, "--", ...args],
+            stdin, cwd, shell, env,
+        });
+    }
+    return { stderr: `${cmdName}: command not found`, exitCode: 127 };
+}
 let _callDepth = 0;
 export async function runCommandDirect(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
     // Anti-loop guard: track call depth via env to avoid infinite recursion
@@ -81,7 +150,7 @@ export async function runCommandDirect(name, args, authUser, hostname, mode, cwd
     }
 }
 async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
-    const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+    const assignRe = ASSIGN_RE;
     const invocation = [name, ...args];
     let assignCount = 0;
     while (assignCount < invocation.length && assignRe.test(invocation[assignCount])) {
@@ -119,42 +188,7 @@ async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd,
     if (!mod) {
         const vfsBinary = resolveVfsBinary(name, env, shell, authUser);
         if (vfsBinary) {
-            const stubContent = shell.vfs.readFile(vfsBinary);
-            const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
-            if (builtinMatch) {
-                const builtinMod = resolveModule(builtinMatch[1]);
-                if (builtinMod) {
-                    return await builtinMod.run({
-                        authUser,
-                        hostname,
-                        activeSessions: shell.users.listActiveSessions(),
-                        rawInput: [name, ...args].join(" "),
-                        mode,
-                        args,
-                        stdin,
-                        cwd,
-                        shell,
-                        env,
-                    });
-                }
-                // builtin not found — stop here, don't fall through to sh -c (avoids infinite loop)
-                return { stderr: `${name}: exec builtin '${builtinMatch[1]}' not found`, exitCode: 127 };
-            }
-            const shMod = resolveModule("sh");
-            if (shMod) {
-                return await shMod.run({
-                    authUser,
-                    hostname,
-                    activeSessions: shell.users.listActiveSessions(),
-                    rawInput: `sh -c ${JSON.stringify(stubContent)}`,
-                    mode,
-                    args: ["-c", stubContent, "--", ...args],
-                    stdin,
-                    cwd,
-                    shell,
-                    env,
-                });
-            }
+            return runVfsStub(vfsBinary, name, args, [name, ...args].join(" "), authUser, hostname, mode, cwd, shell, env, stdin);
         }
         return { stderr: `${name}: command not found`, exitCode: 127 };
     }
@@ -220,18 +254,13 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
             ? trimmed.replace(rawFirstWord, aliasVal)
             : trimmed;
         // Detect sh-syntax constructs that must be handled by the sh interpreter
-        const isShScript = /\bfor\s+\w+\s+in\b/.test(aliasExpanded) ||
-            /\bwhile\s+/.test(aliasExpanded) ||
-            /\bif\s+/.test(aliasExpanded) ||
-            /\w+\s*\(\s*\)\s*\{/.test(aliasExpanded) ||
-            /\bfunction\s+\w+/.test(aliasExpanded) ||
-            /\(\(\s*.+\s*\)\)/.test(aliasExpanded);
-        const hasOperators = /(?<![|&])[|](?![|])/.test(aliasExpanded) ||
-            aliasExpanded.includes(">") ||
-            aliasExpanded.includes("<") ||
-            aliasExpanded.includes("&&") ||
-            aliasExpanded.includes("||") ||
-            aliasExpanded.includes(";");
+        const isShScript = RE_FOR.test(aliasExpanded) ||
+            RE_WHILE.test(aliasExpanded) ||
+            RE_IF.test(aliasExpanded) ||
+            RE_FUNC_BRACE.test(aliasExpanded) ||
+            RE_FUNC_KW.test(aliasExpanded) ||
+            RE_ARITH.test(aliasExpanded);
+        const hasOperators = RE_PIPE.test(aliasExpanded) || RE_OPERATORS.test(aliasExpanded);
         if ((isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") || hasOperators) {
             // sh-syntax: route through sh interpreter to handle for/while/functions
             if (isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") {
@@ -267,52 +296,25 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
         const parts = tokenizeCommand(expanded.trim());
         if (parts.length === 0)
             return { exitCode: 0 };
-        const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+        const assignRe = ASSIGN_RE;
         if (assignRe.test(parts[0])) {
             return runCommandDirect(parts[0], parts.slice(1), authUser, hostname, mode, cwd, shell, stdin, shellEnv);
         }
         const commandName = parts[0]?.toLowerCase() ?? "";
         // Apply brace expansion to each arg token
-        const args = parts.slice(1).flatMap(expandBraces).flatMap(token => expandGlob(token, cwd, shell.vfs));
+        const rawArgs = parts.slice(1);
+        const args = [];
+        for (const token of rawArgs) {
+            for (const brace of expandBraces(token)) {
+                for (const glob of expandGlob(brace, cwd, shell.vfs))
+                    args.push(glob);
+            }
+        }
         const mod = resolveModule(commandName);
         if (!mod) {
             const vfsBinary = resolveVfsBinary(commandName, shellEnv, shell, authUser);
             if (vfsBinary) {
-                const stubContent = shell.vfs.readFile(vfsBinary);
-                const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
-                if (builtinMatch) {
-                    const builtinName = builtinMatch[1];
-                    const builtinMod = resolveModule(builtinName);
-                    if (builtinMod) {
-                        return await builtinMod.run({
-                            authUser,
-                            hostname,
-                            activeSessions: shell.users.listActiveSessions(),
-                            rawInput: [commandName, ...args].join(" "),
-                            mode,
-                            args,
-                            stdin,
-                            cwd,
-                            shell,
-                            env: shellEnv,
-                        });
-                    }
-                }
-                const shMod = resolveModule("sh");
-                if (shMod) {
-                    return await shMod.run({
-                        authUser,
-                        hostname,
-                        activeSessions: shell.users.listActiveSessions(),
-                        rawInput: `sh -c ${JSON.stringify(stubContent)}`,
-                        mode,
-                        args: ["-c", stubContent, "--", ...args],
-                        stdin,
-                        cwd,
-                        shell,
-                        env: shellEnv,
-                    });
-                }
+                return runVfsStub(vfsBinary, commandName, args, expanded, authUser, hostname, mode, cwd, shell, shellEnv, stdin);
             }
             return { stderr: `${commandName}: command not found`, exitCode: 127 };
         }

package/dist/commands/strace.js

@@ -11,7 +11,7 @@ export const straceCommand = {
         const cmd = args.find((a) => !a.startsWith("-"));
         if (!cmd)
             return { stderr: "strace: must have PROG [ARGS] or -p PID", exitCode: 1 };
-        const pid = Math.floor(Math.random() * 30000) + 1000;
+        const _pid = Math.floor(Math.random() * 30000) + 1000;
         const lines = [
             `execve("/usr/bin/${cmd}", ["${cmd}"${args.slice(1).map((a) => `, "${a}"`).join("")}], 0x... /* ... vars */) = 0`,
             `brk(NULL)                               = 0x${(Math.random() * 0xfffff | 0).toString(16)}000`,

package/dist/commands/tar.js

@@ -11,8 +11,8 @@ function makeTarHeader(name, size, isDir) {
     enc(isDir ? "0000755\0" : "0000644\0", 100, 8);
     enc("0000000\0", 108, 8);
     enc("0000000\0", 116, 8);
-    enc(size.toString(8).padStart(11, "0") + "\0", 124, 12);
-    enc(Math.floor(Date.now() / 1000).toString(8).padStart(11, "0") + "\0", 136, 12);
+    enc(`${size.toString(8).padStart(11, "0")}\0`, 124, 12);
+    enc(`${Math.floor(Date.now() / 1000).toString(8).padStart(11, "0")}\0`, 136, 12);
     hdr[156] = isDir ? 0x35 : 0x30; // '5' dir, '0' file
     enc("ustar\0", 257, 6);
     enc("00", 263, 2);

package/dist/commands/test.js

@@ -1,3 +1,4 @@
+import { resolvePath } from "./helpers";
 /**
  * Evaluate a POSIX test expression.
  * Supports: -f, -d, -e, -r, -w, -x, -s, -z, -n,
@@ -33,8 +34,7 @@ function evalTest(tokens, shell, cwd) {
     // Unary file tests
     if (tokens.length === 2) {
         const [flag, operand = ""] = tokens;
-        const resolvePath = (p) => p.startsWith("/") ? p : `${cwd}/${p}`.replace(/\/+/g, "/");
-        const path = resolvePath(operand);
+        const path = resolvePath(cwd, operand);
         switch (flag) {
             case "-e":
                 return shell.vfs.exists(path);

package/dist/modules/linuxRootfs.js

@@ -59,7 +59,11 @@ function bootstrapEtc(vfs, hostname, props) {
     ensureFile(vfs, "/etc/shells", "/bin/sh\n/bin/bash\n/usr/bin/bash\n/bin/dash\n/usr/bin/dash\n");
     ensureFile(vfs, "/etc/profile", `${[
         "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
-        "export PS1='\\u@\\h:\\w\\$ '",
+        "if [ \"$(id -u)\" -eq 0 ]; then",
+        "  export PS1='\\[\\e[37;1m\\][\\[\\e[31;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[31;1m\\]\\$\\[\\e[0m\\] '",
+        "else",
+        "  export PS1='\\[\\e[37;1m\\][\\[\\e[35;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[0m\\]\\$ '",
+        "fi",
     ].join("\n")}\n`);
     ensureFile(vfs, "/etc/issue", "Fortune GNU/Linux 24.04 LTS \\n \\l\n");
     ensureFile(vfs, "/etc/issue.net", "Fortune GNU/Linux 24.04 LTS\n");
@@ -1281,7 +1285,7 @@ Installed-Size: 6800
 Maintainer: Fortune Package Team <dpkg@fortune.local>
 Architecture: amd64
 Version: 1.22.6nyx1
-Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.6)
+Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.8)
 Description: Fortune package management system
  This package provides the low-level infrastructure for handling the
  installation and removal of Fortune software packages.
@@ -1449,7 +1453,7 @@ function bootstrapRoot(vfs) {
     ensureDir(vfs, "/root/.local/share", 0o755);
     ensureFile(vfs, "/root/.bashrc", `${[
         "# root .bashrc",
-        "export PS1='\\[\\033[0;31m\\]\\u@\\h\\[\\033[0m\\]:\\[\\033[0;34m\\]\\w\\[\\033[0m\\]# '",
+        "export PS1='\\[\\e[37;1m\\][\\[\\e[31;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[31;1m\\]\\$\\[\\e[0m\\] '",
         "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
         "export LANG=en_US.UTF-8",
         "alias ll='ls -la'",
@@ -1547,12 +1551,9 @@ export function bootstrapLinuxRootfs(vfs, users, hostname, props, shellStartTime
     const snapshot = getStaticRootfsSnapshot(hostname, props);
     const hasRestoredData = vfs.getMode() === "fs" && vfs.exists("/home");
     if (hasRestoredData) {
-        // Snapshot was already restored — merge static rootfs without
-        // clobbering user files and directories.
         vfs.mergeRootTree(decodeVfs(snapshot));
     }
     else {
-        // Fresh start — replace the empty tree with the full static rootfs.
         vfs.importRootTree(decodeVfs(snapshot));
     }
     bootstrapRoot(vfs);

package/dist/modules/nanoEditor.d.ts

@@ -0,0 +1,92 @@
+import type { TerminalSize } from "./shellRuntime";
+import type { ShellStream } from "../types/streams";
+export type NanoExitReason = "saved" | "aborted";
+export interface NanoEditorOptions {
+    stream: ShellStream;
+    terminalSize: TerminalSize;
+    content: string;
+    filename: string;
+    onExit: (reason: NanoExitReason, content: string) => void;
+    /** Called on ^S / silent save — save without closing nano. Optional. */
+    onSave?: (content: string) => void;
+}
+export declare class NanoEditor {
+    private lines;
+    private cursorRow;
+    private cursorCol;
+    private scrollTop;
+    private modified;
+    private filename;
+    private mode;
+    private inputBuffer;
+    private searchState;
+    private clipboard;
+    private undoStack;
+    private redoStack;
+    private markActive;
+    private readonly stream;
+    private terminalSize;
+    private readonly onExit;
+    private readonly onSave;
+    constructor(opts: NanoEditorOptions);
+    start(): void;
+    resize(size: TerminalSize): void;
+    handleInput(chunk: Buffer): void;
+    private consumeSequence;
+    private handleEscape;
+    private handleAlt;
+    private handleChar;
+    private handleControl;
+    private dispatch;
+    private handlePromptChar;
+    private moveCursor;
+    private moveCursorLeft;
+    private moveCursorRight;
+    private moveCursorHome;
+    private moveCursorEnd;
+    private movePage;
+    private moveWordRight;
+    private moveWordLeft;
+    private pushUndo;
+    private doInsertChar;
+    private doEnter;
+    private doBackspace;
+    private doDelete;
+    private doCutLine;
+    private doUncut;
+    private doUndo;
+    private doRedo;
+    private enterSearch;
+    private doSearch;
+    private doSearchNext;
+    private doSearchReplace;
+    private toggleMark;
+    private doExit;
+    private doSave;
+    private enterWriteout;
+    private showCursorPos;
+    private enterGotoLine;
+    private enterHelp;
+    private get cols();
+    private get rows();
+    private editAreaRows;
+    private editAreaStart;
+    private currentLine;
+    private clampScroll;
+    private getCurrentContent;
+    private pad;
+    fullRedraw(): void;
+    private renderTitleBar;
+    private renderEditArea;
+    private renderLine;
+    private renderCursor;
+    private renderStatusLine;
+    private renderStatusBar;
+    private buildTitleBar;
+    private buildEditArea;
+    private renderLineText;
+    private buildHelpBar;
+    private buildShortcutRow;
+    private buildCursorPosition;
+    private renderHelp;
+}