typescript-virtual-container 1.5.6 → 1.5.7

package/dist/VirtualShell/shellParser.js

@@ -1,3 +1,4 @@
+import { globToRegex } from "../utils/glob";
 import { tokenizeCommand } from "../utils/tokenize";
 // ── Public API ───────────────────────────────────────────────────────────────
 /**
@@ -42,28 +43,6 @@ export function expandGlob(pattern, entries) {
     const matches = entries.filter((e) => regex.test(e));
     return matches.length > 0 ? matches.sort() : [pattern];
 }
-function globToRegex(pattern) {
-    let re = "^";
-    for (let i = 0; i < pattern.length; i++) {
-        const c = pattern[i];
-        if (c === "*")
-            re += ".*";
-        else if (c === "?")
-            re += ".";
-        else if (c === "[") {
-            const close = pattern.indexOf("]", i + 1);
-            if (close === -1)
-                re += "\\[";
-            else {
-                re += `[${pattern.slice(i + 1, close)}]`;
-                i = close;
-            }
-        }
-        else
-            re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-    }
-    return new RegExp(`${re}$`);
-}
 // ── Internal parser ───────────────────────────────────────────────────────────
 function parseStatements(input) {
     // Split by ;, &&, || — respecting quotes and parens

package/dist/commands/exit.js

@@ -5,7 +5,7 @@
  */
 export const exitCommand = {
     name: "exit",
-    aliases: ["bye"],
+    aliases: ["bye", "logout"],
     description: "Exit the shell session",
     category: "shell",
     params: ["[code]"],

package/dist/commands/find.js

@@ -1,3 +1,4 @@
+import { globToRegex } from "../utils/glob";
 import { assertPathAccess, resolvePath } from "./helpers";
 import { runCommand } from "./runtime";
 /**
@@ -109,10 +110,6 @@ export const findCommand = {
             return [{ type: "true" }, pos + 1];
         }
         const pred = exprArgs.length > 0 ? parseExpr(exprArgs, 0)[0] : { type: "true" };
-        function globToRegex(pat, flags = "") {
-            const esc = pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-            return new RegExp(`^${esc}$`, flags);
-        }
         function matchPred(p, fullPath, depth) {
             switch (p.type) {
                 case "true": return true;

package/dist/commands/helpers.d.ts

@@ -1,28 +1,8 @@
 import type VirtualFileSystem from "../VirtualFileSystem";
 import type { VirtualPackageManager } from "../VirtualPackageManager";
 import type { VirtualShell } from "../VirtualShell";
-export declare function normalizeTerminalOutput(text: string): string;
 export declare function resolvePath(cwd: string, inputPath: string, homeDir?: string): string;
 export declare function assertPathAccess(authUser: string, targetPath: string, operation: string): void;
 export declare function stripUrlFilename(url: string): string;
-export declare function fetchResource(url: string): Promise<{
-    text: string;
-    status: number;
-    contentType: string | null;
-}>;
-/**
- * Run a host command like curl or wget and capture its output.
- * @param binary - The binary to execute (e.g., "curl", "wget").
- * @param args - Arguments to pass to the binary.
- * @returns Promise resolving with stdout, stderr, and exit code.
- */
-export declare function runHostCommand(binary: string, args: string[]): Promise<{
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}>;
 export declare function resolveReadablePath(vfs: VirtualFileSystem, cwd: string, inputPath: string): string;
-export declare function joinListWithType(cwd: string, items: string[], statAt: (p: string) => {
-    type: "file" | "directory";
-}): string;
 export declare function getPackageManager(shell: VirtualShell): VirtualPackageManager | undefined;

package/dist/commands/helpers.js

@@ -1,23 +1,5 @@
-import { spawn } from "node:child_process";
 import * as path from "node:path";
 const PROTECTED_PREFIXES = ["/.virtual-env-js/.auth", "/etc/htpasswd"];
-function normalizeFetchUrl(input) {
-    if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input)) {
-        return input;
-    }
-    return `http://${input}`;
-}
-export function normalizeTerminalOutput(text) {
-    return text
-        .replace(/\r\n/g, "\n")
-        .replace(/\r/g, "\n")
-        .replace(/\t/g, "  ")
-        .split("\n")
-        .map((line) => line.replace(/^[ \u00A0]{8,}/, "  ").replace(/[ \u00A0]{3,}/g, "  "))
-        .join("\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .trimEnd();
-}
 export function resolvePath(cwd, inputPath, homeDir) {
     if (!inputPath || inputPath.trim() === "") {
         return cwd;
@@ -49,76 +31,6 @@ export function stripUrlFilename(url) {
     const lastPart = cleaned.split("/").filter(Boolean).pop();
     return lastPart && lastPart.length > 0 ? lastPart : "index.html";
 }
-export async function fetchResource(url) {
-    const response = await fetch(normalizeFetchUrl(url));
-    const contentType = response.headers.get("content-type");
-    return {
-        text: await response.text(),
-        status: response.status,
-        contentType,
-    };
-}
-/**
- * Run a host command like curl or wget and capture its output.
- * @param binary - The binary to execute (e.g., "curl", "wget").
- * @param args - Arguments to pass to the binary.
- * @returns Promise resolving with stdout, stderr, and exit code.
- */
-export function runHostCommand(binary, args) {
-    return new Promise((resolve) => {
-        let childProcess;
-        try {
-            childProcess = spawn(binary, args, {
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (error) {
-            resolve({
-                stdout: "",
-                stderr: `${binary}: ${error instanceof Error ? error.message : String(error)}`,
-                exitCode: 1,
-            });
-            return;
-        }
-        let stdout = "";
-        let stderr = "";
-        const stdoutStream = childProcess.stdout;
-        const stderrStream = childProcess.stderr;
-        if (!stdoutStream || !stderrStream) {
-            resolve({
-                stdout: "",
-                stderr: `${binary}: failed to capture process output`,
-                exitCode: 1,
-            });
-            return;
-        }
-        stdoutStream.setEncoding("utf8");
-        stderrStream.setEncoding("utf8");
-        stdoutStream.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        stderrStream.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        childProcess.on("error", (error) => {
-            const errorCode = error instanceof Error && "code" in error
-                ? String(error.code ?? "")
-                : "";
-            resolve({
-                stdout: "",
-                stderr: `${binary}: ${error.message}`,
-                exitCode: errorCode === "ENOENT" ? 127 : 1,
-            });
-        });
-        childProcess.on("close", (code) => {
-            resolve({
-                stdout,
-                stderr,
-                exitCode: code ?? 1,
-            });
-        });
-    });
-}
 function levenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i += 1) {
@@ -153,15 +65,6 @@ export function resolveReadablePath(vfs, cwd, inputPath) {
     }
     return exactPath;
 }
-export function joinListWithType(cwd, items, statAt) {
-    return items
-        .map((name) => {
-        const childPath = resolvePath(cwd, name);
-        const stats = statAt(childPath);
-        return stats.type === "directory" ? `${name}/` : name;
-    })
-        .join("  ");
-}
 export function getPackageManager(shell) {
     return shell.packageManager;
 }

package/dist/commands/perl.js

@@ -25,7 +25,7 @@ export const perlCommand = {
             for (let li = 0; li < lines.length; li++) {
                 let line = lines[li];
                 // $_ = line, $. = line number
-                let processed = code
+                const processed = code
                     .replace(/\$_/g, JSON.stringify(line))
                     .replace(/\$\./g, String(li + 1));
                 // s/pat/rep/[g] substitution on $_

package/dist/commands/python.js

@@ -694,8 +694,11 @@ class Interpreter {
                     return left.repeat(right);
                 if (Array.isArray(left) && typeof right === "number") {
                     const arr = [];
-                    for (let i = 0; i < right; i++)
-                        arr.push(...left);
+                    const n = right | 0;
+                    for (let i = 0; i < n; i++) {
+                        for (let j = 0; j < left.length; j++)
+                            arr.push(left[j]);
+                    }
                     return arr;
                 }
                 return left * right;

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/runtime.js

@@ -4,6 +4,16 @@ 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}`;
@@ -43,7 +53,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 +79,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 +126,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 +164,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 +230,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 +272,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

@@ -1281,7 +1281,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.7)
 Description: Fortune package management system
  This package provides the low-level infrastructure for handling the
  installation and removal of Fortune software packages.
@@ -1547,12 +1547,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/neofetch.js

@@ -208,10 +208,10 @@ function resolveDefaults(info) {
             os: info.osName ?? `${readOsPrettyName() ?? os.type()} ${os.arch()}`,
             arch: os.arch(),
         },
-        resolution: info.resolution ?? "n/a (ssh)",
+        resolution: info.resolution ?? shellProps?.resolution ?? "n/a (ssh)",
         terminal: info.terminal ?? "unknown",
         cpu: info.cpu ?? resolveCpuLabel(),
-        gpu: info.gpu ?? "n/a",
+        gpu: info.gpu ?? shellProps?.gpu ?? "n/a",
         memoryUsedMiB: info.memoryUsedMiB ?? toMiB(usedMem),
         memoryTotalMiB: info.memoryTotalMiB ?? toMiB(totalMem),
     };

package/dist/types/commands.d.ts

@@ -94,6 +94,10 @@ export interface ShellEnv {
     vars: Record<string, string>;
     /** Exit status of the last executed command. */
     lastExitCode: number;
+    /** @internal Cached split of vars.PATH — invalidated when _pathRaw !== vars.PATH. */
+    _pathRaw?: string;
+    /** @internal Pre-split PATH directories for resolveVfsBinary hot-path. */
+    _pathDirs?: string[];
 }
 /** Runtime context object passed to each command module. */
 export interface CommandContext {

package/dist/utils/argv.d.ts

@@ -0,0 +1,6 @@
+/** Returns true if `name` appears in `argv`. */
+export declare function getFlag(argv: string[], name: string): boolean;
+/** Returns the string value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export declare function getOptionString(argv: string[], name: string, fallback: string): string;
+/** Returns the integer value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export declare function getOptionInt(argv: string[], name: string, fallback: number): number;

package/dist/utils/argv.js

@@ -0,0 +1,32 @@
+/** Returns true if `name` appears in `argv`. */
+export function getFlag(argv, name) {
+    return argv.includes(name);
+}
+/** Returns the string value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export function getOptionString(argv, name, fallback) {
+    const prefix = `${name}=`;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith(prefix))
+            return a.slice(prefix.length);
+        if (a === name) {
+            const next = argv[i + 1];
+            return (next && !next.startsWith("--")) ? next : fallback;
+        }
+    }
+    return fallback;
+}
+/** Returns the integer value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export function getOptionInt(argv, name, fallback) {
+    const prefix = `${name}=`;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith(prefix))
+            return parseInt(a.slice(prefix.length), 10);
+        if (a === name) {
+            const next = argv[i + 1];
+            return next ? parseInt(next, 10) : fallback;
+        }
+    }
+    return fallback;
+}

package/dist/utils/expand.d.ts

@@ -61,10 +61,13 @@ export declare function expandAsync(input: string, env: Record<string, string>,
  * Supports * (any chars in segment) and ** (any path).
  * Returns the original pattern if no matches found (bash behavior).
  */
-export declare function expandGlob(pattern: string, cwd: string, vfs: {
+type GlobVfs = {
     list: (p: string) => string[];
     exists: (p: string) => boolean;
     stat: (p: string) => {
         type: string;
     };
-}): string[];
+    statType?: (p: string) => string | null;
+};
+export declare function expandGlob(pattern: string, cwd: string, vfs: GlobVfs): string[];
+export {};