just-bash 1.0.0

package/dist/commands/seq/seq.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "../../types.js";
+/**
+ * seq - print a sequence of numbers
+ *
+ * Usage:
+ *   seq LAST           - print numbers from 1 to LAST
+ *   seq FIRST LAST     - print numbers from FIRST to LAST
+ *   seq FIRST INCR LAST - print numbers from FIRST to LAST by INCR
+ *
+ * Options:
+ *   -s STRING  use STRING to separate numbers (default: newline)
+ *   -w         equalize width by padding with leading zeros
+ */
+export declare const seqCommand: Command;

package/dist/commands/sleep/sleep.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const sleepCommand: Command;

package/dist/commands/sort/comparator.d.ts

@@ -0,0 +1,9 @@
+import type { SortOptions } from "./types.js";
+/**
+ * Create a comparison function for sorting
+ */
+export declare function createComparator(options: SortOptions): (a: string, b: string) => number;
+/**
+ * Filter unique lines based on key values or whole line
+ */
+export declare function filterUnique(lines: string[], options: SortOptions): string[];

package/dist/commands/sort/parser.d.ts

@@ -0,0 +1,11 @@
+import type { KeySpec } from "./types.js";
+/**
+ * Parse a key specification like:
+ * - "1" - field 1
+ * - "1,2" - fields 1 through 2
+ * - "1.3" - field 1 starting at char 3
+ * - "1.3,2.5" - field 1 char 3 through field 2 char 5
+ * - "1n" - field 1, numeric
+ * - "1,2nr" - fields 1-2, numeric and reverse
+ */
+export declare function parseKeySpec(spec: string): KeySpec | null;

package/dist/commands/sort/sort.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const sortCommand: Command;

package/dist/commands/sort/types.d.ts

@@ -0,0 +1,18 @@
+export interface KeySpec {
+    startField: number;
+    startChar?: number;
+    endField?: number;
+    endChar?: number;
+    numeric?: boolean;
+    reverse?: boolean;
+    ignoreCase?: boolean;
+    ignoreLeading?: boolean;
+}
+export interface SortOptions {
+    reverse: boolean;
+    numeric: boolean;
+    unique: boolean;
+    ignoreCase: boolean;
+    keys: KeySpec[];
+    fieldDelimiter: string | null;
+}

package/dist/commands/stat/stat.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const statCommand: Command;

package/dist/commands/tail/tail.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const tailCommand: Command;

package/dist/commands/tee/tee.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const teeCommand: Command;

package/dist/commands/timeout/timeout.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const timeoutCommand: Command;

package/dist/commands/touch/touch.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const touchCommand: Command;

package/dist/commands/tr/tr.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const trCommand: Command;

package/dist/commands/tree/tree.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const treeCommand: Command;

package/dist/commands/true/true.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "../../types.js";
+export declare const trueCommand: Command;
+export declare const falseCommand: Command;

package/dist/commands/uniq/uniq.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const uniqCommand: Command;

package/dist/commands/wc/wc.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const wcCommand: Command;

package/dist/commands/which/which.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const whichCommand: Command;

package/dist/commands/xargs/xargs.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../../types.js";
+export declare const xargsCommand: Command;

package/dist/fs-interface.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Supported buffer encodings
+ */
+export type BufferEncoding = "utf8" | "utf-8" | "ascii" | "binary" | "base64" | "hex" | "latin1";
+/**
+ * File content can be string or Buffer
+ */
+export type FileContent = string | Uint8Array;
+/**
+ * Options for reading files
+ */
+export interface ReadFileOptions {
+    encoding?: BufferEncoding | null;
+}
+/**
+ * Options for writing files
+ */
+export interface WriteFileOptions {
+    encoding?: BufferEncoding;
+}
+/**
+ * File system entry types
+ */
+export interface FileEntry {
+    type: "file";
+    content: string | Uint8Array;
+    mode: number;
+    mtime: Date;
+}
+export interface DirectoryEntry {
+    type: "directory";
+    mode: number;
+    mtime: Date;
+}
+export interface SymlinkEntry {
+    type: "symlink";
+    target: string;
+    mode: number;
+    mtime: Date;
+}
+export type FsEntry = FileEntry | DirectoryEntry | SymlinkEntry;
+/**
+ * Stat result from the filesystem
+ */
+export interface FsStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    mode: number;
+    size: number;
+    mtime: Date;
+}
+/**
+ * Options for mkdir operation
+ */
+export interface MkdirOptions {
+    recursive?: boolean;
+}
+/**
+ * Options for rm operation
+ */
+export interface RmOptions {
+    recursive?: boolean;
+    force?: boolean;
+}
+/**
+ * Options for cp operation
+ */
+export interface CpOptions {
+    recursive?: boolean;
+}
+/**
+ * Abstract filesystem interface that can be implemented by different backends.
+ * This allows BashEnv to work with:
+ * - VirtualFs (in-memory, default)
+ * - Real filesystem (via node:fs)
+ * - Custom implementations (e.g., remote storage, browser IndexedDB)
+ */
+export interface IFileSystem {
+    /**
+     * Read the contents of a file as a string (default: utf8)
+     * @throws Error if file doesn't exist or is a directory
+     */
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    /**
+     * Read the contents of a file as a Uint8Array (binary)
+     * @throws Error if file doesn't exist or is a directory
+     */
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    /**
+     * Write content to a file, creating it if it doesn't exist
+     */
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    /**
+     * Append content to a file, creating it if it doesn't exist
+     */
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    /**
+     * Check if a path exists
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Get file/directory information
+     * @throws Error if path doesn't exist
+     */
+    stat(path: string): Promise<FsStat>;
+    /**
+     * Create a directory
+     * @throws Error if parent doesn't exist (unless recursive) or path exists
+     */
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    /**
+     * Read directory contents
+     * @returns Array of entry names (not full paths)
+     * @throws Error if path doesn't exist or is not a directory
+     */
+    readdir(path: string): Promise<string[]>;
+    /**
+     * Remove a file or directory
+     * @throws Error if path doesn't exist (unless force) or directory not empty (unless recursive)
+     */
+    rm(path: string, options?: RmOptions): Promise<void>;
+    /**
+     * Copy a file or directory
+     * @throws Error if source doesn't exist or trying to copy directory without recursive
+     */
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    /**
+     * Move/rename a file or directory
+     */
+    mv(src: string, dest: string): Promise<void>;
+    /**
+     * Resolve a relative path against a base path
+     */
+    resolvePath(base: string, path: string): string;
+    /**
+     * Get all paths in the filesystem (useful for glob matching)
+     * Optional - implementations may return empty array if not supported
+     */
+    getAllPaths(): string[];
+    /**
+     * Change file/directory permissions
+     * @throws Error if path doesn't exist
+     */
+    chmod(path: string, mode: number): Promise<void>;
+    /**
+     * Create a symbolic link
+     * @param target - The path the symlink should point to
+     * @param linkPath - The path where the symlink will be created
+     * @throws Error if linkPath already exists
+     */
+    symlink(target: string, linkPath: string): Promise<void>;
+    /**
+     * Create a hard link
+     * @param existingPath - The existing file to link to
+     * @param newPath - The path where the new link will be created
+     * @throws Error if existingPath doesn't exist or newPath already exists
+     */
+    link(existingPath: string, newPath: string): Promise<void>;
+    /**
+     * Read the target of a symbolic link
+     * @throws Error if path doesn't exist or is not a symlink
+     */
+    readlink(path: string): Promise<string>;
+    /**
+     * Get file/directory information without following symlinks
+     * @throws Error if path doesn't exist
+     */
+    lstat(path: string): Promise<FsStat>;
+}
+/**
+ * Extended file initialization options with optional metadata
+ */
+export interface FileInit {
+    content: FileContent;
+    mode?: number;
+    mtime?: Date;
+}
+/**
+ * Initial files can be simple content or extended options with metadata
+ */
+export type InitialFiles = Record<string, FileContent | FileInit>;
+/**
+ * Factory function type for creating filesystem instances
+ */
+export type FileSystemFactory = (initialFiles?: InitialFiles) => IFileSystem;

package/dist/fs.d.ts

@@ -0,0 +1,39 @@
+import type { BufferEncoding, CpOptions, DirectoryEntry, FileContent, FileEntry, FsEntry, FsStat, IFileSystem, InitialFiles, MkdirOptions, ReadFileOptions, RmOptions, SymlinkEntry, WriteFileOptions } from "./fs-interface.js";
+export type { BufferEncoding, FileContent, FileEntry, DirectoryEntry, SymlinkEntry, FsEntry, FsStat, IFileSystem, ReadFileOptions, WriteFileOptions, };
+export interface FsData {
+    [path: string]: FsEntry;
+}
+export declare class VirtualFs implements IFileSystem {
+    private data;
+    constructor(initialFiles?: InitialFiles);
+    private normalizePath;
+    private dirname;
+    private ensureParentDirs;
+    writeFileSync(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding, metadata?: {
+        mode?: number;
+        mtime?: Date;
+    }): void;
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    private resolveSymlink;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    /**
+     * Synchronous version of mkdir
+     */
+    mkdirSync(path: string, options?: MkdirOptions): void;
+    readdir(path: string): Promise<string[]>;
+    rm(path: string, options?: RmOptions): Promise<void>;
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    getAllPaths(): string[];
+    resolvePath(base: string, path: string): string;
+    chmod(path: string, mode: number): Promise<void>;
+    symlink(target: string, linkPath: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export type { BashOptions, ExecOptions } from "./Bash.js";
+export { Bash } from "./Bash.js";
+export type { AllCommandName, CommandName, NetworkCommandName, } from "./commands/registry.js";
+export { getCommandNames, getNetworkCommandNames, } from "./commands/registry.js";
+export { VirtualFs } from "./fs.js";
+export type { BufferEncoding, CpOptions, DirectoryEntry, FileContent, FileEntry, FileInit, FileSystemFactory, FsEntry, FsStat, InitialFiles, MkdirOptions, RmOptions, SymlinkEntry, } from "./fs-interface.js";
+export type { NetworkConfig } from "./network/index.js";
+export { NetworkAccessDeniedError, RedirectNotAllowedError, TooManyRedirectsError, } from "./network/index.js";
+export { OverlayFs, type OverlayFsOptions } from "./overlay-fs/index.js";
+export type { CommandFinished as SandboxCommandFinished, OutputMessage, SandboxOptions, WriteFilesInput, } from "./sandbox/index.js";
+export { Command as SandboxCommand, Sandbox } from "./sandbox/index.js";
+export type { BashExecResult, Command, CommandContext, ExecResult, IFileSystem, } from "./types.js";

package/dist/interpreter/arithmetic.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Arithmetic Evaluation
+ *
+ * Evaluates bash arithmetic expressions including:
+ * - Basic operators (+, -, *, /, %)
+ * - Comparison operators (<, <=, >, >=, ==, !=)
+ * - Bitwise operators (&, |, ^, ~, <<, >>)
+ * - Logical operators (&&, ||, !)
+ * - Assignment operators (=, +=, -=, etc.)
+ * - Ternary operator (? :)
+ * - Pre/post increment/decrement (++, --)
+ * - Nested arithmetic: $((expr))
+ * - Command substitution: $(cmd) or `cmd`
+ *
+ * Known limitations:
+ * - Bitwise operations use JavaScript's 32-bit signed integers, not 64-bit.
+ *   This means values like (1 << 31) will be negative (-2147483648) instead
+ *   of the bash 64-bit result (2147483648).
+ * - Dynamic arithmetic expressions (e.g., ${base}#a where base=16) are not
+ *   fully supported - variable expansion happens at parse time, not runtime.
+ */
+import type { ArithExpr } from "../ast/types.js";
+import type { InterpreterContext } from "./types.js";
+/**
+ * Synchronous version of evaluateArithmetic for simple expressions.
+ * Does not support command substitution - those will return 0.
+ */
+export declare function evaluateArithmeticSync(ctx: InterpreterContext, expr: ArithExpr): number;
+export declare function evaluateArithmetic(ctx: InterpreterContext, expr: ArithExpr): Promise<number>;

package/dist/interpreter/builtins/break.d.ts

@@ -0,0 +1,6 @@
+/**
+ * break - Exit from loops builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleBreak(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/cd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * cd - Change directory builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleCd(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/continue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * continue - Skip to next loop iteration builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleContinue(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/declare.d.ts

@@ -0,0 +1,29 @@
+/**
+ * declare/typeset - Declare variables and give them attributes
+ *
+ * Usage:
+ *   declare              - List all variables
+ *   declare -p           - List all variables (same as no args)
+ *   declare NAME=value   - Declare variable with value
+ *   declare -a NAME      - Declare indexed array
+ *   declare -A NAME      - Declare associative array
+ *   declare -r NAME      - Declare readonly variable
+ *   declare -x NAME      - Export variable
+ *
+ * Also aliased as 'typeset'
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleDeclare(ctx: InterpreterContext, args: string[]): ExecResult;
+/**
+ * Parse array elements from content like "1 2 3" or "'a b' c d"
+ */
+export declare function parseArrayElements(content: string): string[];
+/**
+ * readonly - Declare readonly variables
+ *
+ * Usage:
+ *   readonly NAME=value   - Declare readonly variable
+ *   readonly NAME         - Mark existing variable as readonly
+ */
+export declare function handleReadonly(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/eval.d.ts

@@ -0,0 +1,9 @@
+/**
+ * eval - Execute arguments as a shell command
+ *
+ * Concatenates all arguments and executes them as a shell command
+ * in the current environment (variables persist after eval).
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleEval(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/exit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * exit - Exit shell builtin
+ */
+import type { InterpreterContext } from "../types.js";
+export declare function handleExit(ctx: InterpreterContext, args: string[]): never;

package/dist/interpreter/builtins/export.d.ts

@@ -0,0 +1,13 @@
+/**
+ * export - Set environment variables builtin
+ *
+ * Usage:
+ *   export              - List all exported variables
+ *   export -p           - List all exported variables (same as no args)
+ *   export NAME=value   - Set and export variable
+ *   export NAME         - Export existing variable (or create empty)
+ *   export -n NAME      - Un-export variable (remove from env)
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleExport(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Built-in Command Handlers
+ *
+ * Shell built-in commands that modify interpreter state:
+ * - cd: Change directory
+ * - declare/typeset: Declare variables with attributes
+ * - export: Set environment variables
+ * - unset: Remove variables/functions
+ * - exit: Exit shell
+ * - local: Declare local variables in functions
+ * - readonly: Declare readonly variables
+ * - set: Set/unset shell options
+ * - break: Exit from loops
+ * - continue: Skip to next loop iteration
+ * - return: Return from a function
+ * - eval: Execute arguments as a shell command
+ * - let: Evaluate arithmetic expressions
+ * - shift: Shift positional parameters
+ * - read: Read a line of input
+ * - source/.: Execute commands from a file in current environment
+ */
+export { handleBreak } from "./break.js";
+export { handleCd } from "./cd.js";
+export { handleContinue } from "./continue.js";
+export { handleDeclare, handleReadonly } from "./declare.js";
+export { handleEval } from "./eval.js";
+export { handleExit } from "./exit.js";
+export { handleExport } from "./export.js";
+export { handleLet } from "./let.js";
+export { handleLocal } from "./local.js";
+export { handleRead } from "./read.js";
+export { handleReturn } from "./return.js";
+export { handleSet } from "./set.js";
+export { handleShift } from "./shift.js";
+export { handleSource } from "./source.js";
+export { handleUnset } from "./unset.js";

package/dist/interpreter/builtins/let.d.ts

@@ -0,0 +1,18 @@
+/**
+ * let - Evaluate arithmetic expressions
+ *
+ * Usage:
+ *   let expr [expr ...]
+ *   let "x=1" "y=x+2"
+ *
+ * Each argument is evaluated as an arithmetic expression.
+ * Returns 0 if the last expression evaluates to non-zero,
+ * returns 1 if it evaluates to zero.
+ *
+ * Note: In bash, `let x=( 1 )` passes separate args ["x=(", "1", ")"]
+ * when not quoted. The let builtin needs to handle this by joining
+ * arguments that are part of the same expression.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleLet(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/local.d.ts

@@ -0,0 +1,6 @@
+/**
+ * local - Declare local variables in functions builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleLocal(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/read.d.ts

@@ -0,0 +1,6 @@
+/**
+ * read - Read a line of input builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleRead(ctx: InterpreterContext, args: string[], stdin: string): ExecResult;

package/dist/interpreter/builtins/return.d.ts

@@ -0,0 +1,6 @@
+/**
+ * return - Return from a function with an exit code
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleReturn(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/set.d.ts

@@ -0,0 +1,6 @@
+/**
+ * set - Set/unset shell options builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleSet(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/shift.d.ts

@@ -0,0 +1,12 @@
+/**
+ * shift - Shift positional parameters
+ *
+ * shift [n]
+ *
+ * Shifts positional parameters to the left by n (default 1).
+ * $n+1 becomes $1, $n+2 becomes $2, etc.
+ * $# is decremented by n.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleShift(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/source.d.ts

@@ -0,0 +1,6 @@
+/**
+ * source/. - Execute commands from a file in current environment builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleSource(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/unset.d.ts

@@ -0,0 +1,12 @@
+/**
+ * unset - Remove variables/functions builtin
+ *
+ * Supports:
+ * - unset VAR - remove variable
+ * - unset -v VAR - remove variable (explicit)
+ * - unset -f FUNC - remove function
+ * - unset 'a[i]' - remove array element (with arithmetic index support)
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleUnset(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/variable-helpers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Variable assignment helpers for declare, readonly, local, export builtins.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * Result of parsing an assignment argument.
+ */
+export interface ParsedAssignment {
+    name: string;
+    isArray: boolean;
+    arrayElements?: string[];
+    value?: string;
+}
+/**
+ * Parse an assignment argument like "name=value" or "name=(a b c)".
+ */
+export declare function parseAssignment(arg: string): ParsedAssignment;
+/**
+ * Options for setting a variable.
+ */
+export interface SetVariableOptions {
+    makeReadonly?: boolean;
+    checkReadonly?: boolean;
+}
+/**
+ * Set a variable from a parsed assignment.
+ * Returns an error result if the variable is readonly, otherwise null.
+ */
+export declare function setVariable(ctx: InterpreterContext, assignment: ParsedAssignment, options?: SetVariableOptions): ExecResult | null;

package/dist/interpreter/conditionals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Conditional Expression Evaluation
+ *
+ * Handles:
+ * - [[ ... ]] conditional commands
+ * - [ ... ] and test commands
+ * - File tests (-f, -d, -e, etc.)
+ * - String tests (-z, -n, =, !=)
+ * - Numeric comparisons (-eq, -ne, -lt, etc.)
+ * - Pattern matching (==, =~)
+ */
+import type { ConditionalExpressionNode } from "../ast/types.js";
+import type { ExecResult } from "../types.js";
+import type { InterpreterContext } from "./types.js";
+export declare function evaluateConditional(ctx: InterpreterContext, expr: ConditionalExpressionNode): Promise<boolean>;
+export declare function evaluateTestArgs(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+export declare function matchPattern(value: string, pattern: string): boolean;