just-bash 2.5.5 → 2.6.0

package/dist/commands/awk/ast.d.ts

@@ -82,6 +82,7 @@ export interface AwkGetline {
     type: "getline";
     variable?: string;
     file?: AwkExpr;
+    command?: AwkExpr;
 }
 export interface AwkTuple {
     type: "tuple";

package/dist/commands/awk/interpreter/context.d.ts

@@ -9,6 +9,7 @@ export interface AwkRuntimeContext {
     FS: string;
     OFS: string;
     ORS: string;
+    OFMT: string;
     NR: number;
     NF: number;
     FNR: number;
@@ -20,8 +21,10 @@ export interface AwkRuntimeContext {
     line: string;
     vars: Record<string, AwkValue>;
     arrays: Record<string, Record<string, AwkValue>>;
+    arrayAliases: Map<string, string>;
     ARGC: number;
     ARGV: Record<string, string>;
+    ENVIRON: Record<string, string>;
     functions: Map<string, AwkFunctionDef>;
     lines?: string[];
     lineIndex?: number;
@@ -37,11 +40,17 @@ export interface AwkRuntimeContext {
     loopContinue: boolean;
     returnValue?: AwkValue;
     hasReturn: boolean;
+    inEndBlock: boolean;
     output: string;
     fs?: AwkFileSystem;
     cwd?: string;
     openedFiles: Set<string>;
     random?: () => number;
+    exec?: (cmd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
 }
 export interface CreateContextOptions {
     fieldSep?: RegExp;
@@ -49,5 +58,10 @@ export interface CreateContextOptions {
     maxRecursionDepth?: number;
     fs?: AwkFileSystem;
     cwd?: string;
+    exec?: (cmd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
 }
 export declare function createRuntimeContext(options?: CreateContextOptions): AwkRuntimeContext;

package/dist/commands/awk/interpreter/interpreter.d.ts

@@ -25,6 +25,8 @@ export declare class AwkInterpreter {
     executeLine(line: string): Promise<void>;
     /**
      * Execute all END blocks.
+     * END blocks run even after exit is called, but exit from within
+     * an END block stops further END block execution.
      */
     executeEnd(): Promise<void>;
     /**

package/dist/commands/awk/interpreter/{helpers.d.ts → type-coercion.d.ts}

@@ -6,7 +6,10 @@
 import type { AwkValue } from "./types.js";
 /**
  * Check if a value is truthy in AWK.
- * Numbers are truthy if non-zero, strings if non-empty.
+ * - Numbers: truthy if non-zero
+ * - Empty string: falsy
+ * - String "0": falsy (canonical string representation of zero)
+ * - All other non-empty strings: truthy (including "00", "0.0", etc.)
  */
 export declare function isTruthy(val: AwkValue): boolean;
 /**

package/dist/commands/awk/parser2-print.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AWK Parser Print Context Helpers
+ *
+ * Handles parsing in print/printf context where > and >> are redirection
+ * operators rather than comparison operators.
+ */
+import type { AwkExpr, AwkStmt } from "./ast.js";
+import type { Token, TokenType } from "./lexer.js";
+/**
+ * Interface for parser methods needed by print parsing helpers.
+ * Used to avoid circular dependencies.
+ */
+export interface PrintParserContext {
+    tokens: Token[];
+    pos: number;
+    current(): Token;
+    advance(): Token;
+    match(...types: TokenType[]): boolean;
+    check(type: TokenType): boolean;
+    expect(type: TokenType, message?: string): Token;
+    skipNewlines(): void;
+    parseExpression(): AwkExpr;
+    parseTernary(): AwkExpr;
+    parsePrimary(): AwkExpr;
+    parseAddSub(): AwkExpr;
+    setPos(pos: number): void;
+}
+/**
+ * Parse a print statement.
+ */
+export declare function parsePrintStatement(p: PrintParserContext): AwkStmt;
+/**
+ * Parse a printf statement.
+ */
+export declare function parsePrintfStatement(p: PrintParserContext): AwkStmt;

package/dist/commands/awk/parser2.d.ts

@@ -3,17 +3,19 @@
  *
  * Recursive descent parser that builds an AST from tokens.
  */
-import type { AwkProgram } from "./ast.js";
+import type { AwkExpr, AwkProgram } from "./ast.js";
+import { type Token, TokenType } from "./lexer.js";
 export declare class AwkParser {
-    private tokens;
-    private pos;
+    tokens: Token[];
+    pos: number;
     parse(input: string): AwkProgram;
-    private current;
-    private advance;
-    private match;
-    private check;
-    private expect;
-    private skipNewlines;
+    setPos(newPos: number): void;
+    current(): Token;
+    advance(): Token;
+    match(...types: TokenType[]): boolean;
+    check(type: TokenType): boolean;
+    expect(type: TokenType, message?: string): Token;
+    skipNewlines(): void;
     private skipTerminators;
     private parseProgram;
     private parseFunction;
@@ -24,29 +26,14 @@ export declare class AwkParser {
     private parseWhile;
     private parseDoWhile;
     private parseFor;
-    private parsePrint;
-    /**
-     * Parse a print argument - same as ternary but treats > and >> at the TOP LEVEL
-     * (not inside ternary) as redirection rather than comparison operators.
-     */
-    private parsePrintArg;
-    /**
-     * Look ahead to see if there's a ternary ? operator before the next statement terminator.
-     * This tells us whether > is comparison (in ternary condition) or redirection.
-     */
-    private lookAheadForTernary;
-    private parsePrintOr;
-    private parsePrintAnd;
-    private parsePrintIn;
-    private parsePrintMatch;
+    parseExpression(): AwkExpr;
+    private parseAssignment;
+    parseTernary(): AwkExpr;
     /**
-     * Like parseComparison but doesn't consume > and >> (for print redirection)
+     * Parse command pipe getline: "cmd" | getline [var]
+     * This has lower precedence than logical OR but higher than ternary.
      */
-    private parsePrintComparison;
-    private parsePrintf;
-    private parseExpression;
-    private parseAssignment;
-    private parseTernary;
+    private parsePipeGetline;
     private parseOr;
     /**
      * Continue parsing a logical OR/AND expression from a given left-hand side.
@@ -59,15 +46,36 @@ export declare class AwkParser {
     private parseLogicalAndRest;
     private parseAnd;
     private parseIn;
+    private parseConcatenation;
     private parseMatch;
     private parseComparison;
-    private parseConcatenation;
     private canStartExpression;
-    private isComparisonOrHigherOp;
-    private parseAddSub;
+    /**
+     * Check if the current token terminates a concatenation.
+     * These are tokens that indicate we've reached a higher-level operator
+     * or end of expression.
+     */
+    private isConcatTerminator;
+    parseAddSub(): AwkExpr;
     private parseMulDiv;
     private parseUnary;
     private parsePower;
     private parsePostfix;
-    private parsePrimary;
+    /**
+     * Parse a field index expression. This is like parseUnary but does NOT allow
+     * postfix operators, so that $i++ parses as ($i)++ rather than $(i++).
+     * Allows: $1, $i, $++i, $--i, $(expr), $-1
+     * Does NOT consume postfix ++ or -- (those apply to the field, not the index)
+     */
+    private parseFieldIndex;
+    /**
+     * Parse power expression for field index (no postfix on base)
+     */
+    private parseFieldIndexPower;
+    /**
+     * Parse primary expression for field index - like parsePrimary but returns
+     * without checking for postfix operators
+     */
+    private parseFieldIndexPrimary;
+    parsePrimary(): AwkExpr;
 }

package/dist/commands/printf/strftime.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Strftime Formatting Functions
+ *
+ * Handles date/time formatting for printf's %(...)T directive.
+ */
+/**
+ * Format a timestamp using strftime-like format string.
+ */
+export declare function formatStrftime(format: string, timestamp: number, tz?: string): string;

package/dist/commands/query-engine/builtins/array-builtins.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Array-related jq builtins
+ *
+ * Handles array manipulation functions like sort, sort_by, group_by, max, min, add, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type EvalWithPartialFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type CompareFn = (a: QueryValue, b: QueryValue) => number;
+type IsTruthyFn = (v: QueryValue) => boolean;
+type ContainsDeepFn = (a: QueryValue, b: QueryValue) => boolean;
+type ExecutionLimitErrorClass = new (message: string, kind: "recursion" | "commands" | "iterations") => Error;
+/**
+ * Handle array builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not an array builtin handled here.
+ */
+export declare function evalArrayBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, evaluateWithPartialResults: EvalWithPartialFn, compareJq: CompareFn, isTruthy: IsTruthyFn, containsDeep: ContainsDeepFn, ExecutionLimitError: ExecutionLimitErrorClass): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/control-builtins.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Control flow jq builtins
+ *
+ * Handles first, last, nth, range, limit, isempty, isvalid, skip, until, while, repeat.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type EvalWithPartialFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type IsTruthyFn = (v: QueryValue) => boolean;
+type ExecutionLimitErrorClass = new (message: string, kind: "recursion" | "commands" | "iterations") => Error;
+/**
+ * Handle control flow builtins.
+ * Returns null if the builtin name is not a control builtin handled here.
+ */
+export declare function evalControlBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, evaluateWithPartialResults: EvalWithPartialFn, isTruthy: IsTruthyFn, ExecutionLimitError: ExecutionLimitErrorClass): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/date-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Date/time-related jq builtins
+ *
+ * Handles date and time functions like now, gmtime, mktime, strftime, strptime, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle date builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a date builtin handled here.
+ */
+export declare function evalDateBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/format-builtins.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Format-related jq builtins (@ prefixed)
+ *
+ * Handles encoding/formatting functions like @base64, @uri, @csv, @json, etc.
+ */
+import type { QueryValue } from "../value-operations.js";
+/**
+ * Handle format builtins (those starting with @).
+ * Returns null if the builtin name is not a format builtin handled here.
+ */
+export declare function evalFormatBuiltin(value: QueryValue, name: string, maxDepth?: number): QueryValue[] | null;

package/dist/commands/query-engine/builtins/index-builtins.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Index-related jq builtins
+ *
+ * Handles index, rindex, and indices functions for finding positions in arrays/strings.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type DeepEqualFn = (a: QueryValue, b: QueryValue) => boolean;
+/**
+ * Handle index builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not an index builtin handled here.
+ */
+export declare function evalIndexBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, deepEqual: DeepEqualFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * jq builtin functions index
+ *
+ * Re-exports all builtin handlers from category-specific modules.
+ */
+export { evalArrayBuiltin } from "./array-builtins.js";
+export { evalControlBuiltin } from "./control-builtins.js";
+export { evalDateBuiltin } from "./date-builtins.js";
+export { evalFormatBuiltin } from "./format-builtins.js";
+export { evalIndexBuiltin } from "./index-builtins.js";
+export { evalMathBuiltin } from "./math-builtins.js";
+export { evalNavigationBuiltin } from "./navigation-builtins.js";
+export { evalObjectBuiltin } from "./object-builtins.js";
+export { evalPathBuiltin } from "./path-builtins.js";
+export { evalSqlBuiltin } from "./sql-builtins.js";
+export { evalStringBuiltin } from "./string-builtins.js";
+export { evalTypeBuiltin } from "./type-builtins.js";

package/dist/commands/query-engine/builtins/math-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Math-related jq builtins
+ *
+ * Handles mathematical functions like abs, pow, exp, trig functions, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle math builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a math builtin handled here.
+ */
+export declare function evalMathBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/navigation-builtins.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Navigation and traversal jq builtins
+ *
+ * Handles recurse, recurse_down, walk, transpose, combinations, parent, parents, root.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type IsTruthyFn = (v: QueryValue) => boolean;
+type GetValueAtPathFn = (obj: QueryValue, path: (string | number)[]) => QueryValue;
+type EvalBuiltinFn = (value: QueryValue, name: string, args: AstNode[], ctx: EvalContext) => QueryValue[];
+/**
+ * Handle navigation builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a navigation builtin handled here.
+ */
+export declare function evalNavigationBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, isTruthy: IsTruthyFn, getValueAtPath: GetValueAtPathFn, evalBuiltin: EvalBuiltinFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/object-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Object-related jq builtins
+ *
+ * Handles object manipulation functions like keys, to_entries, from_entries, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import { type QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle object builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not an object builtin handled here.
+ */
+export declare function evalObjectBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/path-builtins.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Path-related jq builtins
+ *
+ * Handles path manipulation functions like getpath, setpath, delpaths, paths, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type IsTruthyFn = (v: QueryValue) => boolean;
+type SetPathFn = (obj: QueryValue, path: (string | number)[], val: QueryValue) => QueryValue;
+type DeletePathFn = (obj: QueryValue, path: (string | number)[]) => QueryValue;
+type ApplyDelFn = (value: QueryValue, expr: AstNode, ctx: EvalContext) => QueryValue;
+type CollectPathsFn = (value: QueryValue, expr: AstNode, ctx: EvalContext, currentPath: (string | number)[], paths: (string | number)[][]) => void;
+/**
+ * Handle path builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a path builtin handled here.
+ */
+export declare function evalPathBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, isTruthy: IsTruthyFn, setPath: SetPathFn, deletePath: DeletePathFn, applyDel: ApplyDelFn, collectPaths: CollectPathsFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/sql-builtins.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SQL-like jq builtins
+ *
+ * Handles IN, INDEX, and JOIN functions.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type DeepEqualFn = (a: QueryValue, b: QueryValue) => boolean;
+/**
+ * Handle SQL-like builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a SQL builtin handled here.
+ */
+export declare function evalSqlBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, deepEqual: DeepEqualFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/string-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * String-related jq builtins
+ *
+ * Handles string manipulation functions like join, split, test, match, gsub, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle string builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a string builtin handled here.
+ */
+export declare function evalStringBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/type-builtins.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Type-related jq builtins
+ *
+ * Handles type checking and type filtering functions like type, numbers, strings, etc.
+ */
+import type { QueryValue } from "../value-operations.js";
+/**
+ * Handle type builtins.
+ * Returns null if the builtin name is not a type builtin handled here.
+ */
+export declare function evalTypeBuiltin(value: QueryValue, name: string): QueryValue[] | null;

package/dist/commands/query-engine/evaluator.d.ts

@@ -5,18 +5,26 @@
  * Used by jq, yq, and other query-based commands.
  */
 import type { AstNode } from "./parser.js";
-export type QueryValue = unknown;
+import { type QueryValue } from "./value-operations.js";
+export type { QueryValue } from "./value-operations.js";
 export interface QueryExecutionLimits {
     maxIterations?: number;
+    maxDepth?: number;
 }
 export interface EvalContext {
     vars: Map<string, QueryValue>;
-    limits: Required<QueryExecutionLimits>;
+    limits: Required<Pick<QueryExecutionLimits, "maxIterations">> & QueryExecutionLimits;
     env?: Record<string, string | undefined>;
     /** Original document root for parent/root navigation */
     root?: QueryValue;
     /** Current path from root for parent navigation */
     currentPath?: (string | number)[];
+    funcs?: Map<string, {
+        params: string[];
+        body: AstNode;
+        closure?: Map<string, unknown>;
+    }>;
+    labels?: Set<string>;
 }
 export interface EvaluateOptions {
     limits?: QueryExecutionLimits;

package/dist/commands/query-engine/parser-types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Query expression parser types
+ *
+ * AST node types and token types for jq-style filter expressions.
+ */
+export type TokenType = "DOT" | "PIPE" | "COMMA" | "COLON" | "SEMICOLON" | "LPAREN" | "RPAREN" | "LBRACKET" | "RBRACKET" | "LBRACE" | "RBRACE" | "QUESTION" | "PLUS" | "MINUS" | "STAR" | "SLASH" | "PERCENT" | "EQ" | "NE" | "LT" | "LE" | "GT" | "GE" | "AND" | "OR" | "NOT" | "ALT" | "ASSIGN" | "UPDATE_ADD" | "UPDATE_SUB" | "UPDATE_MUL" | "UPDATE_DIV" | "UPDATE_MOD" | "UPDATE_ALT" | "UPDATE_PIPE" | "IDENT" | "NUMBER" | "STRING" | "IF" | "THEN" | "ELIF" | "ELSE" | "END" | "AS" | "TRY" | "CATCH" | "TRUE" | "FALSE" | "NULL" | "REDUCE" | "FOREACH" | "LABEL" | "BREAK" | "DEF" | "DOTDOT" | "EOF";
+export interface Token {
+    type: TokenType;
+    value?: string | number;
+    pos: number;
+}
+export type AstNode = IdentityNode | FieldNode | IndexNode | SliceNode | IterateNode | PipeNode | CommaNode | LiteralNode | ArrayNode | ObjectNode | ParenNode | BinaryOpNode | UnaryOpNode | CondNode | TryNode | CallNode | VarBindNode | VarRefNode | RecurseNode | OptionalNode | StringInterpNode | UpdateOpNode | ReduceNode | ForeachNode | LabelNode | BreakNode | DefNode;
+export interface IdentityNode {
+    type: "Identity";
+}
+export interface FieldNode {
+    type: "Field";
+    name: string;
+    base?: AstNode;
+}
+export interface IndexNode {
+    type: "Index";
+    index: AstNode;
+    base?: AstNode;
+}
+export interface SliceNode {
+    type: "Slice";
+    start?: AstNode;
+    end?: AstNode;
+    base?: AstNode;
+}
+export interface IterateNode {
+    type: "Iterate";
+    base?: AstNode;
+}
+export interface PipeNode {
+    type: "Pipe";
+    left: AstNode;
+    right: AstNode;
+}
+export interface CommaNode {
+    type: "Comma";
+    left: AstNode;
+    right: AstNode;
+}
+export interface LiteralNode {
+    type: "Literal";
+    value: unknown;
+}
+export interface ArrayNode {
+    type: "Array";
+    elements?: AstNode;
+}
+export interface ObjectNode {
+    type: "Object";
+    entries: {
+        key: AstNode | string;
+        value: AstNode;
+    }[];
+}
+export interface ParenNode {
+    type: "Paren";
+    expr: AstNode;
+}
+export interface BinaryOpNode {
+    type: "BinaryOp";
+    op: "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "and" | "or" | "//";
+    left: AstNode;
+    right: AstNode;
+}
+export interface UnaryOpNode {
+    type: "UnaryOp";
+    op: "-" | "not";
+    operand: AstNode;
+}
+export interface CondNode {
+    type: "Cond";
+    cond: AstNode;
+    then: AstNode;
+    elifs: {
+        cond: AstNode;
+        then: AstNode;
+    }[];
+    else?: AstNode;
+}
+export interface TryNode {
+    type: "Try";
+    body: AstNode;
+    catch?: AstNode;
+}
+export interface CallNode {
+    type: "Call";
+    name: string;
+    args: AstNode[];
+}
+export interface VarBindNode {
+    type: "VarBind";
+    name: string;
+    value: AstNode;
+    body: AstNode;
+    pattern?: DestructurePattern;
+    alternatives?: DestructurePattern[];
+}
+export type DestructurePattern = {
+    type: "var";
+    name: string;
+} | {
+    type: "array";
+    elements: DestructurePattern[];
+} | {
+    type: "object";
+    fields: {
+        key: string | AstNode;
+        pattern: DestructurePattern;
+        keyVar?: string;
+    }[];
+};
+export interface VarRefNode {
+    type: "VarRef";
+    name: string;
+}
+export interface RecurseNode {
+    type: "Recurse";
+}
+export interface OptionalNode {
+    type: "Optional";
+    expr: AstNode;
+}
+export interface StringInterpNode {
+    type: "StringInterp";
+    parts: (string | AstNode)[];
+}
+export interface UpdateOpNode {
+    type: "UpdateOp";
+    op: "+=" | "-=" | "*=" | "/=" | "%=" | "//=" | "=" | "|=";
+    path: AstNode;
+    value: AstNode;
+}
+export interface ReduceNode {
+    type: "Reduce";
+    expr: AstNode;
+    varName: string;
+    pattern?: DestructurePattern;
+    init: AstNode;
+    update: AstNode;
+}
+export interface ForeachNode {
+    type: "Foreach";
+    expr: AstNode;
+    varName: string;
+    pattern?: DestructurePattern;
+    init: AstNode;
+    update: AstNode;
+    extract?: AstNode;
+}
+export interface LabelNode {
+    type: "Label";
+    name: string;
+    body: AstNode;
+}
+export interface BreakNode {
+    type: "Break";
+    name: string;
+}
+export interface DefNode {
+    type: "Def";
+    name: string;
+    params: string[];
+    funcBody: AstNode;
+    body: AstNode;
+}