@eidos.space/just-bash 3.0.2

package/dist/network/types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Network configuration types
+ *
+ * Network access is disabled by default. To enable network access (e.g., for curl),
+ * you must explicitly configure allowed URLs.
+ */
+/**
+ * DNS lookup result used for private IP resolution checks
+ */
+export interface DnsLookupResult {
+    address: string;
+    family: number;
+}
+/**
+ * HTTP methods that can be allowed
+ */
+export type HttpMethod = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
+/**
+ * Header transform applied at the fetch boundary.
+ * Headers specified here override any user-supplied headers with the same name.
+ */
+export interface RequestTransform {
+    headers: Record<string, string>;
+}
+/**
+ * An allowed URL entry with optional header transforms.
+ * Transforms are applied at the fetch boundary so secrets never enter the sandbox.
+ */
+export interface AllowedUrl {
+    url: string;
+    transform?: RequestTransform[];
+}
+/**
+ * An entry in the allowedUrlPrefixes list: either a plain URL string or
+ * an object with a URL and optional transforms.
+ */
+export type AllowedUrlEntry = string | AllowedUrl;
+/**
+ * Configuration for network access
+ */
+export interface NetworkConfig {
+    /**
+     * List of allowed URL prefixes. Each entry must be a full origin (scheme + host),
+     * optionally followed by a path prefix:
+     * - An origin: "https://api.example.com" - allows all paths on this origin
+     * - An origin + path prefix: "https://api.example.com/v1/" - allows only paths starting with /v1/
+     *
+     * Entries can be plain strings or objects with transforms for credentials brokering:
+     * ```
+     * allowedUrlPrefixes: [
+     *   "https://other-api.com",
+     *   {
+     *     url: "https://ai-gateway.vercel.sh",
+     *     transform: [{ headers: { "Authorization": "Bearer secret" } }],
+     *   },
+     * ]
+     * ```
+     *
+     * The check is performed on the full URL, so "https://api.example.com/v1" will allow:
+     * - https://api.example.com/v1
+     * - https://api.example.com/v1/users
+     * - https://api.example.com/v1/users/123
+     *
+     * But NOT:
+     * - https://api.example.com/v10
+     * - https://api.example.com/v1-admin
+     * - https://api.example.com/v2/users
+     * - https://api.example.org/v1/users (different origin)
+     * - URLs that rely on ambiguous encoded separators like %2f or %5c
+     *
+     * Invalid entries (missing scheme, missing host, relative paths) will throw an error.
+     */
+    allowedUrlPrefixes?: AllowedUrlEntry[];
+    /**
+     * List of allowed HTTP methods. Defaults to ["GET", "HEAD"] for safety.
+     * dangerouslyAllowFullInternetAccess to enables all methods.
+     */
+    allowedMethods?: HttpMethod[];
+    /**
+     * Bypass the allow-list and allow all URLs and methods.
+     * DANGEROUS: Only use this in trusted environments.
+     */
+    dangerouslyAllowFullInternetAccess?: boolean;
+    /**
+     * Maximum number of redirects to follow (default: 20)
+     */
+    maxRedirects?: number;
+    /**
+     * Request timeout in milliseconds (default: 30000)
+     */
+    timeoutMs?: number;
+    /**
+     * Maximum response body size in bytes (default: 10MB).
+     * Responses larger than this will be rejected with ResponseTooLargeError.
+     */
+    maxResponseSize?: number;
+    /**
+     * Reject URLs with private/loopback IP addresses as hostnames.
+     * Performs both lexical hostname checks and DNS resolution to catch
+     * domains that resolve to private IPs (e.g., DNS rebinding attacks).
+     * Useful for mitigating SSRF attacks. Default: false (opt-in).
+     *
+     * When enabled, the private IP check is enforced even when
+     * `dangerouslyAllowFullInternetAccess` is true, ensuring that
+     * internal/loopback addresses are never reachable.
+     */
+    denyPrivateRanges?: boolean;
+    /**
+     * @internal Override DNS resolution for testing.
+     * When set, used instead of the default `dns.lookup` for the
+     * denyPrivateRanges DNS rebinding check.
+     */
+    _dnsResolve?: (hostname: string) => Promise<DnsLookupResult[]>;
+}
+/**
+ * Result of a network fetch operation
+ */
+export interface FetchResult {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    /** Raw response bytes (never decoded as UTF-8 text). */
+    body: Uint8Array;
+    url: string;
+}
+/**
+ * Error thrown when a URL is not allowed
+ */
+export declare class NetworkAccessDeniedError extends Error {
+    constructor(url: string, reason?: string);
+}
+/**
+ * Error thrown when too many redirects occur
+ */
+export declare class TooManyRedirectsError extends Error {
+    constructor(maxRedirects: number);
+}
+/**
+ * Error thrown when a redirect target is not allowed
+ */
+export declare class RedirectNotAllowedError extends Error {
+    constructor(url: string);
+}
+/**
+ * Error thrown when an HTTP method is not allowed
+ */
+export declare class MethodNotAllowedError extends Error {
+    constructor(method: string, allowedMethods: string[]);
+}
+/**
+ * Error thrown when a response body exceeds the maximum allowed size
+ */
+export declare class ResponseTooLargeError extends Error {
+    constructor(maxSize: number);
+}

package/dist/parser/arithmetic-parser.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Arithmetic Expression Parser
+ *
+ * Parses bash arithmetic expressions like:
+ * - $((1 + 2))
+ * - $((x++))
+ * - $((a ? b : c))
+ * - $((2#1010))
+ *
+ * All functions take a Parser instance as the first argument for shared state access.
+ */
+import type { ArithExpr, ArithmeticExpressionNode } from "../ast/types.js";
+import { parseArithNumber } from "./arithmetic-primaries.js";
+import type { Parser } from "./parser.js";
+export { parseArithNumber };
+/**
+ * Parse an arithmetic expression string into an AST node
+ */
+export declare function parseArithmeticExpression(_p: Parser, input: string): ArithmeticExpressionNode;
+export declare function parseArithExpr(p: Parser, input: string, pos: number): {
+    expr: ArithExpr;
+    pos: number;
+};

package/dist/parser/arithmetic-primaries.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Helper functions for parsing primary arithmetic expressions
+ */
+import type { ArithExpr } from "../ast/types.js";
+import type { Parser } from "./parser.js";
+/**
+ * Skip whitespace in arithmetic expression input.
+ * Also handles line continuations (backslash followed by newline).
+ */
+export declare function skipArithWhitespace(input: string, pos: number): number;
+/**
+ * Assignment operators in arithmetic expressions
+ */
+export declare const ARITH_ASSIGN_OPS: readonly ["=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "|=", "^="];
+/**
+ * Parse a number string with various bases (decimal, hex, octal, base#num)
+ * Returns NaN for invalid numbers.
+ */
+export declare function parseArithNumber(str: string): number;
+/**
+ * Parse nested arithmetic expression: $((expr))
+ */
+export declare function parseNestedArithmetic(parseArithExpr: (p: Parser, input: string, pos: number) => {
+    expr: ArithExpr;
+    pos: number;
+}, p: Parser, input: string, currentPos: number): {
+    expr: ArithExpr;
+    pos: number;
+} | null;
+/**
+ * Parse ANSI-C quoting: $'...'
+ * Returns the numeric value of the string content
+ */
+export declare function parseAnsiCQuoting(input: string, currentPos: number): {
+    expr: ArithExpr;
+    pos: number;
+} | null;
+/**
+ * Parse localization quoting: $"..."
+ * Returns the numeric value of the string content
+ */
+export declare function parseLocalizationQuoting(input: string, currentPos: number): {
+    expr: ArithExpr;
+    pos: number;
+} | null;

package/dist/parser/command-parser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Command Parser
+ *
+ * Handles parsing of simple commands, redirections, and assignments.
+ */
+import { type RedirectionNode, type SimpleCommandNode } from "../ast/types.js";
+import type { Parser } from "./parser.js";
+export declare function isRedirection(p: Parser): boolean;
+export declare function parseRedirection(p: Parser): RedirectionNode;
+export declare function parseSimpleCommand(p: Parser): SimpleCommandNode;

package/dist/parser/compound-parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compound Command Parser
+ *
+ * Handles parsing of compound commands: if, for, while, until, case, subshell, group.
+ */
+import { type CaseNode, type CStyleForNode, type ForNode, type GroupNode, type IfNode, type SubshellNode, type UntilNode, type WhileNode } from "../ast/types.js";
+import type { Parser } from "./parser.js";
+export declare function parseIf(p: Parser, options?: {
+    skipRedirections?: boolean;
+}): IfNode;
+export declare function parseFor(p: Parser, options?: {
+    skipRedirections?: boolean;
+}): ForNode | CStyleForNode;
+export declare function parseWhile(p: Parser, options?: {
+    skipRedirections?: boolean;
+}): WhileNode;
+export declare function parseUntil(p: Parser, options?: {
+    skipRedirections?: boolean;
+}): UntilNode;
+export declare function parseCase(p: Parser, options?: {
+    skipRedirections?: boolean;
+}): CaseNode;
+export declare function parseSubshell(p: Parser, options?: {
+    skipRedirections?: boolean;
+}): SubshellNode | CStyleForNode;
+export declare function parseGroup(p: Parser, options?: {
+    skipRedirections?: boolean;
+}): GroupNode;

package/dist/parser/conditional-parser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Conditional Expression Parser
+ *
+ * Handles parsing of [[ ... ]] conditional commands.
+ */
+import type { ConditionalExpressionNode } from "../ast/types.js";
+import type { Parser } from "./parser.js";
+export declare function parseConditionalExpression(p: Parser): ConditionalExpressionNode;

package/dist/parser/expansion-parser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Expansion Parser
+ *
+ * Handles parsing of parameter expansions, arithmetic expansions, etc.
+ */
+import { type WordPart } from "../ast/types.js";
+import type { Parser } from "./parser.js";
+export declare function parseWordParts(p: Parser, value: string, quoted?: boolean, singleQuoted?: boolean, isAssignment?: boolean, hereDoc?: boolean, 
+/** When true, single quotes are treated as literal characters, not quote delimiters */
+singleQuotesAreLiteral?: boolean, 
+/** When true, brace expansion is disabled (used in [[ ]] conditionals) */
+noBraceExpansion?: boolean, 
+/** When true, all backslash escapes create Escaped nodes (for regex patterns in [[ =~ ]]) */
+regexPattern?: boolean, 
+/** When true, \} is treated as escaped } (used in parameter expansion default values) */
+inParameterExpansion?: boolean): WordPart[];

package/dist/parser/lexer.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Lexer for Bash Scripts
+ *
+ * The lexer tokenizes input into a stream of tokens that the parser consumes.
+ * It handles:
+ * - Operators and delimiters
+ * - Words (with quoting rules)
+ * - Comments
+ * - Here-documents
+ * - Escape sequences
+ */
+export interface LexerOptions {
+    /** Maximum heredoc size in bytes (default: 10MB) */
+    maxHeredocSize?: number;
+}
+export declare enum TokenType {
+    EOF = "EOF",
+    NEWLINE = "NEWLINE",
+    SEMICOLON = "SEMICOLON",
+    AMP = "AMP",// &
+    PIPE = "PIPE",// |
+    PIPE_AMP = "PIPE_AMP",// |&
+    AND_AND = "AND_AND",// &&
+    OR_OR = "OR_OR",// ||
+    BANG = "BANG",// !
+    LESS = "LESS",// <
+    GREAT = "GREAT",// >
+    DLESS = "DLESS",// <<
+    DGREAT = "DGREAT",// >>
+    LESSAND = "LESSAND",// <&
+    GREATAND = "GREATAND",// >&
+    LESSGREAT = "LESSGREAT",// <>
+    DLESSDASH = "DLESSDASH",// <<-
+    CLOBBER = "CLOBBER",// >|
+    TLESS = "TLESS",// <<<
+    AND_GREAT = "AND_GREAT",// &>
+    AND_DGREAT = "AND_DGREAT",// &>>
+    LPAREN = "LPAREN",// (
+    RPAREN = "RPAREN",// )
+    LBRACE = "LBRACE",// {
+    RBRACE = "RBRACE",// }
+    DSEMI = "DSEMI",// ;;
+    SEMI_AND = "SEMI_AND",// ;&
+    SEMI_SEMI_AND = "SEMI_SEMI_AND",// ;;&
+    DBRACK_START = "DBRACK_START",// [[
+    DBRACK_END = "DBRACK_END",// ]]
+    DPAREN_START = "DPAREN_START",// ((
+    DPAREN_END = "DPAREN_END",// ))
+    IF = "IF",
+    THEN = "THEN",
+    ELSE = "ELSE",
+    ELIF = "ELIF",
+    FI = "FI",
+    FOR = "FOR",
+    WHILE = "WHILE",
+    UNTIL = "UNTIL",
+    DO = "DO",
+    DONE = "DONE",
+    CASE = "CASE",
+    ESAC = "ESAC",
+    IN = "IN",
+    FUNCTION = "FUNCTION",
+    SELECT = "SELECT",
+    TIME = "TIME",
+    COPROC = "COPROC",
+    WORD = "WORD",
+    NAME = "NAME",// Valid variable name
+    NUMBER = "NUMBER",// For redirections like 2>&1
+    ASSIGNMENT_WORD = "ASSIGNMENT_WORD",// VAR=value
+    FD_VARIABLE = "FD_VARIABLE",// {varname} before redirect operator
+    COMMENT = "COMMENT",
+    HEREDOC_CONTENT = "HEREDOC_CONTENT"
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    /** Original position in input */
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+    /** For WORD tokens: quote information */
+    quoted?: boolean;
+    singleQuoted?: boolean;
+}
+/**
+ * Error thrown when the lexer encounters invalid input
+ */
+export declare class LexerError extends Error {
+    line: number;
+    column: number;
+    constructor(message: string, line: number, column: number);
+}
+/**
+ * Lexer class
+ */
+export declare class Lexer {
+    private input;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    private pendingHeredocs;
+    private dparenDepth;
+    private maxHeredocSize;
+    constructor(input: string, options?: LexerOptions);
+    /**
+     * Tokenize the entire input
+     */
+    tokenize(): Token[];
+    private skipWhitespace;
+    private nextToken;
+    /**
+     * Look ahead from position after (( to determine if this is nested subshells
+     * like ((cmd) || (cmd2)) rather than arithmetic like ((1+2)).
+     *
+     * Returns true if it looks like nested subshells (command invocation).
+     */
+    private looksLikeNestedSubshells;
+    private makeToken;
+    private readComment;
+    private readWord;
+    private readHeredocContent;
+    /**
+     * Register a here-document to be read after the next newline
+     */
+    addPendingHeredoc(delimiter: string, stripTabs: boolean, quoted: boolean): void;
+    /**
+     * Look ahead from current position to find the here-doc delimiter
+     * and register it as a pending here-doc
+     */
+    private registerHeredocFromLookahead;
+    /**
+     * Check if position is followed by word characters (not a word boundary).
+     * Used to determine if } should be literal or RBRACE token.
+     */
+    private isWordCharFollowing;
+    /**
+     * Read a word that starts with a brace expansion.
+     * Includes the brace expansion plus any suffix characters and additional brace expansions.
+     */
+    private readWordWithBraceExpansion;
+    /**
+     * Scan ahead to detect brace expansion pattern.
+     * Returns the full brace expansion string if found, null otherwise.
+     * Brace expansion must contain either:
+     * - A comma (e.g., {a,b,c})
+     * - A range with .. (e.g., {1..10})
+     */
+    private scanBraceExpansion;
+    /**
+     * Scan a literal brace word like {foo} (no comma, no range).
+     * Returns the literal string if found, null otherwise.
+     * This is used when {} contains something but it's not a valid brace expansion.
+     */
+    private scanLiteralBraceWord;
+    /**
+     * Scan an extglob pattern starting at the opening parenthesis.
+     * Extglob patterns are: @(...), *(...), +(...), ?(...), !(...)
+     * The operator (@, *, +, ?, !) is already consumed; we start at the (.
+     * Returns the content including parentheses, or null if not a valid extglob.
+     */
+    private scanExtglobPattern;
+    /**
+     * Scan for FD variable syntax: {varname} immediately followed by a redirect operator.
+     * This is the bash 4.1+ feature where {fd}>file allocates an FD and stores it in variable.
+     * Returns the variable name and end position if found, null otherwise.
+     *
+     * Valid patterns:
+     * - {varname}>file, {varname}>>file, {varname}>|file
+     * - {varname}<file, {varname}<<word, {varname}<<<word
+     * - {varname}<>file
+     * - {varname}>&N, {varname}<&N
+     * - {varname}>&-, {varname}<&- (close FD)
+     */
+    private scanFdVariable;
+    /**
+     * Scan ahead from a $(( position to determine if it should be treated as
+     * $( ( subshell ) ) instead of $(( arithmetic )).
+     * This handles cases like:
+     *   echo $(( echo 1
+     *   echo 2
+     *   ) )
+     * which should be a command substitution containing a subshell, not arithmetic.
+     *
+     * @param startPos - position at the second ( (i.e., at input[startPos] === "(")
+     * @returns true if this is a subshell (closes with ) )), false if arithmetic (closes with )))
+     */
+    private dollarDparenIsSubshell;
+    /**
+     * Scan ahead from a (( position to determine if it closes with ) ) (nested subshells)
+     * or )) (arithmetic). We need to track paren depth and quotes to find the matching close.
+     * @param startPos - position after the (( (i.e., at the first char of content)
+     * @returns true if it closes with ) ) (space between parens), false otherwise
+     */
+    private dparenClosesWithSpacedParens;
+}

package/dist/parser/parser-substitution.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Command and Arithmetic Substitution Parsing Helpers
+ *
+ * Contains pure string analysis functions and substitution parsing utilities
+ * extracted from the main parser.
+ */
+import { type CommandSubstitutionPart, type ScriptNode } from "../ast/types.js";
+/**
+ * Type for a parser factory function that creates new parser instances.
+ * Used to avoid circular dependencies.
+ */
+export type ParserFactory = () => {
+    parse(input: string): ScriptNode;
+};
+/**
+ * Type for an error reporting function.
+ */
+export type ErrorFn = (message: string) => never;
+/**
+ * Check if $(( at position `start` in `value` is a command substitution with nested
+ * subshell rather than arithmetic expansion. This uses similar logic to the lexer's
+ * dparenClosesWithSpacedParens but operates on a string within a word/expansion.
+ *
+ * The key heuristics are:
+ * 1. If it closes with `) )` (separated by whitespace or content), it's a subshell
+ * 2. If at depth 1 we see `||`, `&&`, or single `|`, it's a command context
+ * 3. If it closes with `))`, it's arithmetic
+ *
+ * @param value The string containing the expansion
+ * @param start Position of the `$` in `$((` (so `$((` is at start..start+2)
+ * @returns true if this should be parsed as command substitution, false for arithmetic
+ */
+export declare function isDollarDparenSubshell(value: string, start: number): boolean;
+/**
+ * Parse a command substitution starting at the given position.
+ * Handles $(...) syntax with proper depth tracking for nested substitutions.
+ *
+ * @param value The string containing the substitution
+ * @param start Position of the `$` in `$(`
+ * @param createParser Factory function to create a new parser instance
+ * @param error Error reporting function
+ * @returns The parsed command substitution part and the ending index
+ */
+export declare function parseCommandSubstitutionFromString(value: string, start: number, createParser: ParserFactory, error: ErrorFn): {
+    part: CommandSubstitutionPart;
+    endIndex: number;
+};
+/**
+ * Parse a backtick command substitution starting at the given position.
+ * Handles `...` syntax with proper escape processing.
+ *
+ * @param value The string containing the substitution
+ * @param start Position of the opening backtick
+ * @param inDoubleQuotes Whether the backtick is inside double quotes
+ * @param createParser Factory function to create a new parser instance
+ * @param error Error reporting function
+ * @returns The parsed command substitution part and the ending index
+ */
+export declare function parseBacktickSubstitutionFromString(value: string, start: number, inDoubleQuotes: boolean, createParser: ParserFactory, error: ErrorFn): {
+    part: CommandSubstitutionPart;
+    endIndex: number;
+};

package/dist/parser/parser.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Recursive Descent Parser for Bash Scripts
+ *
+ * This parser consumes tokens from the lexer and produces an AST.
+ * It follows the bash grammar structure for correctness.
+ *
+ * Grammar (simplified):
+ *   script       ::= statement*
+ *   statement    ::= pipeline ((&&|'||') pipeline)*  [&]
+ *   pipeline     ::= [!] command (| command)*
+ *   command      ::= simple_command | compound_command | function_def
+ *   simple_cmd   ::= (assignment)* [word] (word)* (redirection)*
+ *   compound_cmd ::= if | for | while | until | case | subshell | group | (( | [[
+ */
+import { type ArithmeticExpansionPart, type ArithmeticExpressionNode, type CommandSubstitutionPart, type RedirectionNode, type ScriptNode, type StatementNode, type WordNode } from "../ast/types.js";
+import { type LexerOptions, type Token, TokenType } from "./lexer.js";
+export type { ParseError } from "./types.js";
+export { ParseException } from "./types.js";
+/**
+ * Parser class - transforms tokens into AST
+ */
+export declare class Parser {
+    private tokens;
+    private pos;
+    private pendingHeredocs;
+    private parseIterations;
+    private parseDepth;
+    private _input;
+    /**
+     * Get the raw input string being parsed.
+     * Used by conditional-parser for extracting exact whitespace in regex patterns.
+     */
+    getInput(): string;
+    /**
+     * Check parse iteration limit to prevent infinite loops
+     */
+    checkIterationLimit(): void;
+    /**
+     * Increment parse depth and check limit to prevent stack overflow
+     * from deeply nested constructs. Returns a function to decrement depth.
+     */
+    enterDepth(): () => void;
+    /**
+     * Parse a bash script string
+     */
+    parse(input: string, options?: LexerOptions): ScriptNode;
+    /**
+     * Parse from pre-tokenized input
+     */
+    parseTokens(tokens: Token[]): ScriptNode;
+    current(): Token;
+    peek(offset?: number): Token;
+    advance(): Token;
+    getPos(): number;
+    /**
+     * Check if current token matches any of the given types.
+     * Optimized to avoid array allocation for common cases (1-4 args).
+     */
+    check(t1: TokenType, t2?: TokenType, t3?: TokenType, t4?: TokenType, ...rest: TokenType[]): boolean;
+    expect(type: TokenType, message?: string): Token;
+    error(message: string): never;
+    skipNewlines(): void;
+    skipSeparators(includeCaseTerminators?: boolean): void;
+    addPendingHeredoc(redirect: RedirectionNode, delimiter: string, stripTabs: boolean, quoted: boolean): void;
+    private processHeredocs;
+    isStatementEnd(): boolean;
+    private isCommandStart;
+    private parseScript;
+    /**
+     * Check for unexpected tokens that can't appear at statement start.
+     * Returns a deferred error statement for tokens that should cause errors
+     * at execution time rather than parse time (to match bash's incremental behavior).
+     */
+    private checkUnexpectedToken;
+    parseStatement(): StatementNode | null;
+    private parsePipeline;
+    private parseCommand;
+    /**
+     * Scan ahead from current DPAREN_START to determine if it closes with ) )
+     * (two separate RPAREN tokens) or )) (DPAREN_END token).
+     * Returns true if it closes with ) ) (nested subshells case).
+     */
+    private dparenClosesWithSpacedParens;
+    /**
+     * Parse (( ... ) ) as nested subshells when we know it closes with ) ).
+     * We've already determined via dparenClosesWithSpacedParens() that this
+     * DPAREN_START should be treated as two LPAREN tokens.
+     */
+    private parseNestedSubshellsFromDparen;
+    isWord(): boolean;
+    parseWord(): WordNode;
+    /**
+     * Parse a word without brace expansion (for [[ ]] conditionals).
+     * In bash, brace expansion does not occur inside [[ ]].
+     */
+    parseWordNoBraceExpansion(): WordNode;
+    /**
+     * Parse a word for regex patterns (in [[ =~ ]]).
+     * All escaped characters create Escaped nodes so the backslash is preserved
+     * for the regex engine. For example, \$ creates Escaped("$") which becomes \$
+     * in the final regex pattern.
+     */
+    parseWordForRegex(): WordNode;
+    parseWordFromString(value: string, quoted?: boolean, singleQuoted?: boolean, isAssignment?: boolean, hereDoc?: boolean, noBraceExpansion?: boolean, regexPattern?: boolean): WordNode;
+    parseCommandSubstitution(value: string, start: number): {
+        part: CommandSubstitutionPart;
+        endIndex: number;
+    };
+    parseBacktickSubstitution(value: string, start: number, 
+    /** Whether the backtick is inside double quotes */
+    inDoubleQuotes?: boolean): {
+        part: CommandSubstitutionPart;
+        endIndex: number;
+    };
+    /**
+     * Check if $(( at position `start` in `value` is a command substitution with nested
+     * subshell rather than arithmetic expansion.
+     */
+    isDollarDparenSubshell(value: string, start: number): boolean;
+    parseArithmeticExpansion(value: string, start: number): {
+        part: ArithmeticExpansionPart;
+        endIndex: number;
+    };
+    private parseArithmeticCommand;
+    private parseConditionalCommand;
+    private parseFunctionDef;
+    private parseCompoundCommandBody;
+    parseCompoundList(): StatementNode[];
+    parseOptionalRedirections(): RedirectionNode[];
+    parseArithmeticExpression(input: string): ArithmeticExpressionNode;
+}
+/**
+ * Convenience function to parse a bash script
+ */
+export declare function parse(input: string, options?: LexerOptions): ScriptNode;