just-binary 2.9.8

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

@@ -0,0 +1,29 @@
+/**
+ * Directory Stack Builtins: pushd, popd, dirs
+ *
+ * pushd [dir] - Push directory onto stack and cd to it
+ * popd - Pop directory from stack and cd to previous
+ * dirs [-clpv] - Display directory stack
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * pushd - Push directory onto stack and cd to it
+ *
+ * pushd [dir] - Push current dir, cd to dir
+ */
+export declare function handlePushd(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+/**
+ * popd - Pop directory from stack and cd to it
+ */
+export declare function handlePopd(ctx: InterpreterContext, args: string[]): ExecResult;
+/**
+ * dirs - Display directory stack
+ *
+ * dirs [-clpv]
+ *   -c: Clear the stack
+ *   -l: Long format (no tilde substitution)
+ *   -p: One entry per line
+ *   -v: One entry per line with index numbers
+ */
+export declare function handleDirs(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[], stdin?: Uint8Array): 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,14 @@
+/**
+ * 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+=value  - Append value 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/getopts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * getopts - Parse positional parameters as options
+ *
+ * getopts optstring name [arg...]
+ *
+ * Parses options from positional parameters (or provided args).
+ * - optstring: string of valid option characters
+ * - If a character is followed by ':', it requires an argument
+ * - If optstring starts with ':', silent error reporting mode
+ * - name: variable to store the current option
+ * - OPTARG: set to the option argument (if any)
+ * - OPTIND: index of next argument to process (starts at 1)
+ *
+ * Returns 0 if option found, 1 if end of options or error.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleGetopts(ctx: InterpreterContext, args: string[]): ExecResult;

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

@@ -0,0 +1,19 @@
+/**
+ * hash - Manage the hash table of remembered command locations
+ *
+ * hash [-lr] [-p pathname] [-dt] [name ...]
+ *
+ * Hash maintains a hash table of recently executed commands for faster lookup.
+ *
+ * Options:
+ *   (no args)  Display the hash table
+ *   name       Add name to the hash table (look up in PATH)
+ *   -r         Clear the hash table
+ *   -d name    Remove name from the hash table
+ *   -l         Display in a format that can be reused as input
+ *   -p path    Use path as the full pathname for name (hash -p /path name)
+ *   -t name    Print the remembered location of name
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleHash(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

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

@@ -0,0 +1,12 @@
+/**
+ * help - Display helpful information about builtin commands
+ *
+ * Usage: help [-s] [pattern ...]
+ *
+ * If PATTERN is specified, gives detailed help on all commands matching PATTERN,
+ * otherwise a list of the builtins is printed. The -s option restricts the output
+ * for each builtin command matching PATTERN to a short usage synopsis.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleHelp(_ctx: InterpreterContext, args: string[]): ExecResult;

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

@@ -0,0 +1,45 @@
+/**
+ * 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 { handleCompgen } from "./compgen.js";
+export { handleComplete } from "./complete.js";
+export { handleCompopt } from "./compopt.js";
+export { handleContinue } from "./continue.js";
+export { applyCaseTransform, handleDeclare, handleReadonly, isInteger, } from "./declare.js";
+export { handleDirs, handlePopd, handlePushd } from "./dirs.js";
+export { handleEval } from "./eval.js";
+export { handleExit } from "./exit.js";
+export { handleExport } from "./export.js";
+export { handleGetopts } from "./getopts.js";
+export { handleHash } from "./hash.js";
+export { handleHelp } from "./help.js";
+export { handleLet } from "./let.js";
+export { handleLocal } from "./local.js";
+export { handleMapfile } from "./mapfile.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";
+export { getLocalVarDepth } from "./variable-assignment.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[]): Promise<ExecResult>;

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

@@ -0,0 +1,17 @@
+/**
+ * mapfile/readarray - Read lines from stdin into an array
+ *
+ * Usage: mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [array]
+ *        readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [array]
+ *
+ * Options:
+ *   -d delim   Use delim as line delimiter (default: newline)
+ *   -n count   Read at most count lines (0 = all)
+ *   -O origin  Start assigning at index origin (default: 0)
+ *   -s count   Skip first count lines
+ *   -t         Remove trailing delimiter from each line
+ *   array      Array name (default: MAPFILE)
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleMapfile(ctx: InterpreterContext, args: string[], stdinBytes: Uint8Array): 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[], stdinBytes: Uint8Array, stdinSourceFd?: number): 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,9 @@
+/**
+ * set - Set/unset shell options builtin
+ *
+ * In POSIX mode (set -o posix), errors from set (like invalid options)
+ * cause the script to exit immediately.
+ */
+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,15 @@
+/**
+ * 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.
+ *
+ * In POSIX mode (set -o posix), errors from shift (like shift count
+ * exceeding available parameters) cause the script to exit immediately.
+ */
+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/shopt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * shopt builtin - Shell options
+ * Implements bash's shopt builtin for managing shell-specific options
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleShopt(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,16 @@
+/**
+ * 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)
+ *
+ * Bash-specific unset scoping:
+ * - local-unset (same scope): value-unset - clears value but keeps local cell
+ * - dynamic-unset (different scope): cell-unset - removes local cell, exposes outer value
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleUnset(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

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

@@ -0,0 +1,66 @@
+/**
+ * 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;
+    /** For array index assignment: a[index]=value */
+    arrayIndex?: string;
+}
+/**
+ * Parse an assignment argument like "name=value", "name=(a b c)", or "name[index]=value".
+ */
+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): Promise<ExecResult | null>;
+/**
+ * Mark a variable as being declared at the current call depth.
+ * Used for bash-specific unset scoping behavior.
+ */
+export declare function markLocalVarDepth(ctx: InterpreterContext, name: string): void;
+/**
+ * Get the call depth at which a local variable was declared.
+ * Returns undefined if the variable is not a local variable.
+ */
+export declare function getLocalVarDepth(ctx: InterpreterContext, name: string): number | undefined;
+/**
+ * Clear the local variable depth tracking for a variable.
+ * Called when a local variable is cell-unset (dynamic-unset).
+ */
+export declare function clearLocalVarDepth(ctx: InterpreterContext, name: string): void;
+/**
+ * Push the current value of a variable onto the local var stack.
+ * Used for bash's localvar-nest behavior where nested local declarations
+ * each create a new cell that can be unset independently.
+ */
+export declare function pushLocalVarStack(ctx: InterpreterContext, name: string, currentValue: Uint8Array | undefined): void;
+/**
+ * Pop the top entry from the local var stack for a variable.
+ * Returns the saved value and scope index if there was an entry, or undefined if the stack was empty.
+ */
+export declare function popLocalVarStack(ctx: InterpreterContext, name: string): {
+    value: Uint8Array | undefined;
+    scopeIndex: number;
+} | undefined;
+/**
+ * Clear all local var stack entries for a specific scope index.
+ * Called when a function returns and its local scope is popped.
+ */
+export declare function clearLocalVarStackForScope(ctx: InterpreterContext, scopeIndex: number): void;

package/dist/interpreter/command-resolution.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Command Resolution
+ *
+ * Handles PATH-based command resolution and lookup for external commands.
+ */
+import type { IFileSystem } from "../fs/interface.js";
+import type { Command, CommandRegistry } from "../types.js";
+import type { InterpreterState } from "./types.js";
+/**
+ * Context needed for command resolution
+ */
+export interface CommandResolutionContext {
+    fs: IFileSystem;
+    state: InterpreterState;
+    commands: CommandRegistry;
+}
+/**
+ * Result type for command resolution
+ */
+export type ResolveCommandResult = {
+    cmd: Command;
+    path: string;
+} | {
+    script: true;
+    path: string;
+} | {
+    error: "not_found" | "permission_denied";
+    path?: string;
+} | null;
+/**
+ * Resolve a command name to its implementation via PATH lookup.
+ * Returns the command and its resolved path, or null if not found.
+ *
+ * Resolution order:
+ * 1. If command contains "/", resolve as a path
+ * 2. Search PATH directories for the command file
+ * 3. Fall back to registry lookup (for non-InMemoryFs filesystems like OverlayFs)
+ */
+export declare function resolveCommand(ctx: CommandResolutionContext, commandName: string, pathOverride?: string): Promise<ResolveCommandResult>;
+/**
+ * Find all paths for a command in PATH (for `which -a`).
+ */
+export declare function findCommandInPath(ctx: CommandResolutionContext, commandName: string): Promise<string[]>;

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, nocasematch?: boolean, extglob?: boolean): boolean;

package/dist/interpreter/control-flow.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Control Flow Execution
+ *
+ * Handles control flow constructs:
+ * - if/elif/else
+ * - for loops
+ * - C-style for loops
+ * - while loops
+ * - until loops
+ * - case statements
+ * - break/continue
+ */
+import type { CaseNode, CStyleForNode, ForNode, IfNode, UntilNode, WhileNode } from "../ast/types.js";
+import type { ExecResult } from "../types.js";
+import type { InterpreterContext } from "./types.js";
+export declare function executeIf(ctx: InterpreterContext, node: IfNode): Promise<ExecResult>;
+export declare function executeFor(ctx: InterpreterContext, node: ForNode): Promise<ExecResult>;
+export declare function executeCStyleFor(ctx: InterpreterContext, node: CStyleForNode): Promise<ExecResult>;
+export declare function executeWhile(ctx: InterpreterContext, node: WhileNode, stdin?: Uint8Array): Promise<ExecResult>;
+export declare function executeUntil(ctx: InterpreterContext, node: UntilNode): Promise<ExecResult>;
+export declare function executeCase(ctx: InterpreterContext, node: CaseNode): Promise<ExecResult>;

package/dist/interpreter/errors.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Control Flow Errors
+ *
+ * Error classes used to implement shell control flow:
+ * - break: Exit loops
+ * - continue: Skip to next iteration
+ * - return: Exit functions
+ * - errexit: Exit on error (set -e)
+ * - nounset: Error on unset variables (set -u)
+ *
+ * All control flow errors carry stdout/stderr to accumulate output
+ * as they propagate through the execution stack.
+ */
+/**
+ * Base class for all control flow errors.
+ * Carries stdout/stderr to preserve output during propagation.
+ */
+declare abstract class ControlFlowError extends Error {
+    stdout: Uint8Array;
+    stderr: Uint8Array;
+    constructor(message: string, stdout?: Uint8Array, stderr?: Uint8Array);
+    /**
+     * Prepend output from the current context before re-throwing.
+     */
+    prependOutput(stdout: Uint8Array, stderr: Uint8Array): void;
+}
+/**
+ * Error thrown when break is called to exit loops.
+ */
+export declare class BreakError extends ControlFlowError {
+    levels: number;
+    readonly name = "BreakError";
+    constructor(levels?: number, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown when continue is called to skip to next iteration.
+ */
+export declare class ContinueError extends ControlFlowError {
+    levels: number;
+    readonly name = "ContinueError";
+    constructor(levels?: number, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown when return is called to exit a function.
+ */
+export declare class ReturnError extends ControlFlowError {
+    exitCode: number;
+    readonly name = "ReturnError";
+    constructor(exitCode?: number, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown when set -e (errexit) is enabled and a command fails.
+ */
+export declare class ErrexitError extends ControlFlowError {
+    readonly exitCode: number;
+    readonly name = "ErrexitError";
+    constructor(exitCode: number, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown when set -u (nounset) is enabled and an unset variable is referenced.
+ */
+export declare class NounsetError extends ControlFlowError {
+    varName: string;
+    readonly name = "NounsetError";
+    constructor(varName: string, stdout?: Uint8Array);
+}
+/**
+ * Error thrown when exit builtin is called to terminate the script.
+ */
+export declare class ExitError extends ControlFlowError {
+    readonly exitCode: number;
+    readonly name = "ExitError";
+    constructor(exitCode: number, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown for arithmetic expression errors (e.g., floating point, invalid syntax).
+ * Returns exit code 1 instead of 2 (syntax error).
+ */
+export declare class ArithmeticError extends ControlFlowError {
+    readonly name = "ArithmeticError";
+    /**
+     * If true, this error should abort script execution (like missing operand after binary operator).
+     * If false, the error is recoverable and execution can continue.
+     */
+    fatal: boolean;
+    constructor(message: string, stdout?: Uint8Array, stderr?: Uint8Array, fatal?: boolean);
+}
+/**
+ * Error thrown for bad substitution errors (e.g., ${#var:1:3}).
+ * Returns exit code 1.
+ */
+export declare class BadSubstitutionError extends ControlFlowError {
+    readonly name = "BadSubstitutionError";
+    constructor(message: string, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown when failglob is enabled and a glob pattern has no matches.
+ * Returns exit code 1.
+ */
+export declare class GlobError extends ControlFlowError {
+    readonly name = "GlobError";
+    constructor(pattern: string, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown for invalid brace expansions (e.g., mixed case character ranges like {z..A}).
+ * Returns exit code 1 (matching bash behavior).
+ */
+export declare class BraceExpansionError extends ControlFlowError {
+    readonly name = "BraceExpansionError";
+    constructor(message: string, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown when execution limits are exceeded (recursion depth, command count, loop iterations).
+ * This should ALWAYS be thrown before JavaScript's native RangeError kicks in.
+ * Exit code 126 indicates a limit was exceeded.
+ */
+export declare class ExecutionLimitError extends ControlFlowError {
+    readonly limitType: "recursion" | "commands" | "iterations" | "string_length" | "glob_operations" | "substitution_depth";
+    readonly name = "ExecutionLimitError";
+    static readonly EXIT_CODE = 126;
+    constructor(message: string, limitType: "recursion" | "commands" | "iterations" | "string_length" | "glob_operations" | "substitution_depth", stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Error thrown when break/continue is called in a subshell that was
+ * spawned from within a loop context. Causes the subshell to exit cleanly.
+ */
+export declare class SubshellExitError extends ControlFlowError {
+    readonly name = "SubshellExitError";
+    constructor(stdout?: Uint8Array, stderr?: Uint8Array);
+}
+/**
+ * Type guard for errors that exit the current scope (return, break, continue).
+ * These need special handling vs errexit/nounset which terminate execution.
+ */
+export declare function isScopeExitError(error: unknown): error is BreakError | ContinueError | ReturnError;
+/**
+ * Error thrown when a POSIX special builtin fails in POSIX mode.
+ * In POSIX mode (set -o posix), errors in special builtins like
+ * shift, set, readonly, export, etc. cause the entire script to exit.
+ *
+ * Per POSIX 2.8.1 - Consequences of Shell Errors:
+ * "A special built-in utility causes an interactive or non-interactive shell
+ * to exit when an error occurs."
+ */
+export declare class PosixFatalError extends ControlFlowError {
+    readonly exitCode: number;
+    readonly name = "PosixFatalError";
+    constructor(exitCode: number, stdout?: Uint8Array, stderr?: Uint8Array);
+}
+export {};

package/dist/interpreter/expansion/analysis.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Word Analysis
+ *
+ * Functions for analyzing word parts to determine what types of expansions are present.
+ */
+import type { ParameterExpansionPart, WordPart } from "../../ast/types.js";
+/**
+ * Check if a glob pattern string contains variable references ($var or ${var})
+ * This is used to detect when IFS splitting should apply to expanded glob patterns.
+ */
+export declare function globPatternHasVarRef(pattern: string): boolean;
+/**
+ * Check if a parameter expansion's operation word is entirely quoted (all parts are quoted).
+ * This is different from hasQuotedOperationWord which returns true if ANY part is quoted.
+ *
+ * For word splitting purposes:
+ * - ${v:-"AxBxC"} - entirely quoted, should NOT be split
+ * - ${v:-x"AxBxC"x} - mixed quoted/unquoted, SHOULD be split (on unquoted parts)
+ * - ${v:-AxBxC} - entirely unquoted, SHOULD be split
+ */
+export declare function isOperationWordEntirelyQuoted(part: ParameterExpansionPart): boolean;
+/**
+ * Result of analyzing word parts
+ */
+export interface WordPartsAnalysis {
+    hasQuoted: boolean;
+    hasCommandSub: boolean;
+    hasArrayVar: boolean;
+    hasArrayAtExpansion: boolean;
+    hasParamExpansion: boolean;
+    hasVarNamePrefixExpansion: boolean;
+    hasIndirection: boolean;
+}
+/**
+ * Analyze word parts for expansion behavior
+ */
+export declare function analyzeWordParts(parts: WordPart[]): WordPartsAnalysis;

package/dist/interpreter/expansion/arith-text-expansion.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Arithmetic Text Expansion
+ *
+ * Functions for expanding variables within arithmetic expression text.
+ * This handles the bash behavior where $(( $x * 3 )) with x='1 + 2' should
+ * expand to $(( 1 + 2 * 3 )) = 7, not $(( (1+2) * 3 )) = 9.
+ */
+import type { InterpreterContext } from "../types.js";
+/**
+ * Expand $var patterns in arithmetic expression text for text substitution.
+ * Only expands simple $var patterns, not ${...}, $(()), $(), etc.
+ */
+export declare function expandDollarVarsInArithText(ctx: InterpreterContext, text: string): Promise<string>;
+/**
+ * Expand variable references and command substitutions in an array subscript.
+ * e.g., "${array[@]}" -> "1 2 3", "$(echo 1)" -> "1"
+ * This is needed for associative array subscripts like assoc["${array[@]}"]
+ * where the subscript may contain variable or array expansions.
+ */
+export declare function expandSubscriptForAssocArray(ctx: InterpreterContext, subscript: string): Promise<string>;