shell-dsl 0.0.38 → 0.0.40

package/dist/cjs/src/interpreter/context.cjs

@@ -56,7 +56,10 @@ function createCommandContext(options) {
   if (options.exec) {
     ctx.exec = options.exec;
   }
+  if (options.shell) {
+    ctx.shell = options.shell;
+  }
   return ctx;
 }
 
-//# debugId=F914897FD3ECFE8664756E2164756E21
+//# debugId=A1213B6F49E1441764756E2164756E21

package/dist/cjs/src/interpreter/context.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/interpreter/context.ts"],
   "sourcesContent": [
-    "import type { CommandContext, VirtualFS, Stdin, Stdout, Stderr, ExecResult } from \"../types.cjs\";\n\nexport interface ContextOptions {\n  args: string[];\n  stdin: Stdin;\n  stdout: Stdout;\n  stderr: Stderr;\n  fs: VirtualFS;\n  cwd: string;\n  env: Record<string, string>;\n  setCwd: (path: string) => void;\n  exec?: (name: string, args: string[]) => Promise<ExecResult>;\n}\n\nexport function createCommandContext(options: ContextOptions): CommandContext {\n  const ctx: CommandContext = {\n    args: options.args,\n    stdin: options.stdin,\n    stdout: options.stdout,\n    stderr: options.stderr,\n    fs: options.fs,\n    cwd: options.cwd,\n    env: options.env,\n    setCwd: options.setCwd,\n  };\n  if (options.exec) {\n    ctx.exec = options.exec;\n  }\n  return ctx;\n}\n"
+    "import type { CommandContext, VirtualFS, Stdin, Stdout, Stderr, ExecResult, ShellCommandApi } from \"../types.cjs\";\n\nexport interface ContextOptions {\n  args: string[];\n  stdin: Stdin;\n  stdout: Stdout;\n  stderr: Stderr;\n  fs: VirtualFS;\n  cwd: string;\n  env: Record<string, string>;\n  setCwd: (path: string) => void;\n  exec?: (name: string, args: string[]) => Promise<ExecResult>;\n  shell?: ShellCommandApi;\n}\n\nexport function createCommandContext(options: ContextOptions): CommandContext {\n  const ctx: CommandContext = {\n    args: options.args,\n    stdin: options.stdin,\n    stdout: options.stdout,\n    stderr: options.stderr,\n    fs: options.fs,\n    cwd: options.cwd,\n    env: options.env,\n    setCwd: options.setCwd,\n  };\n  if (options.exec) {\n    ctx.exec = options.exec;\n  }\n  if (options.shell) {\n    ctx.shell = options.shell;\n  }\n  return ctx;\n}\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcO,SAAS,oBAAoB,CAAC,SAAyC;AAAA,EAC5E,MAAM,MAAsB;AAAA,IAC1B,MAAM,QAAQ;AAAA,IACd,OAAO,QAAQ;AAAA,IACf,QAAQ,QAAQ;AAAA,IAChB,QAAQ,QAAQ;AAAA,IAChB,IAAI,QAAQ;AAAA,IACZ,KAAK,QAAQ;AAAA,IACb,KAAK,QAAQ;AAAA,IACb,QAAQ,QAAQ;AAAA,EAClB;AAAA,EACA,IAAI,QAAQ,MAAM;AAAA,IAChB,IAAI,OAAO,QAAQ;AAAA,EACrB;AAAA,EACA,OAAO;AAAA;",
-  "debugId": "F914897FD3ECFE8664756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,SAAS,oBAAoB,CAAC,SAAyC;AAAA,EAC5E,MAAM,MAAsB;AAAA,IAC1B,MAAM,QAAQ;AAAA,IACd,OAAO,QAAQ;AAAA,IACf,QAAQ,QAAQ;AAAA,IAChB,QAAQ,QAAQ;AAAA,IAChB,IAAI,QAAQ;AAAA,IACZ,KAAK,QAAQ;AAAA,IACb,KAAK,QAAQ;AAAA,IACb,QAAQ,QAAQ;AAAA,EAClB;AAAA,EACA,IAAI,QAAQ,MAAM;AAAA,IAChB,IAAI,OAAO,QAAQ;AAAA,EACrB;AAAA,EACA,IAAI,QAAQ,OAAO;AAAA,IACjB,IAAI,QAAQ,QAAQ;AAAA,EACtB;AAAA,EACA,OAAO;AAAA;",
+  "debugId": "A1213B6F49E1441764756E2164756E21",
   "names": []
 }

package/dist/cjs/src/interpreter/index.cjs

@@ -41,6 +41,7 @@ var exports_interpreter = {};
 __export(exports_interpreter, {
   createCommandContext: () => import_context.createCommandContext,
   Interpreter: () => import_interpreter.Interpreter,
+  ExitException: () => import_interpreter.ExitException,
   ContinueException: () => import_interpreter.ContinueException,
   BreakException: () => import_interpreter.BreakException
 });
@@ -48,4 +49,4 @@ module.exports = __toCommonJS(exports_interpreter);
 var import_interpreter = require("./interpreter.cjs");
 var import_context = require("./context.cjs");
 
-//# debugId=D80D067B497FC53D64756E2164756E21
+//# debugId=478C5E50B11BB65664756E2164756E21

package/dist/cjs/src/interpreter/index.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/interpreter/index.ts"],
   "sourcesContent": [
-    "export { Interpreter, type InterpreterOptions, BreakException, ContinueException } from \"./interpreter.cjs\";\nexport { createCommandContext, type ContextOptions } from \"./context.cjs\";\n"
+    "export { Interpreter, type InterpreterOptions, BreakException, ContinueException, ExitException } from \"./interpreter.cjs\";\nexport { createCommandContext, type ContextOptions } from \"./context.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAwF,IAAxF;AAC0D,IAA1D;",
-  "debugId": "D80D067B497FC53D64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAuG,IAAvG;AAC0D,IAA1D;",
+  "debugId": "478C5E50B11BB65664756E2164756E21",
   "names": []
 }

package/dist/cjs/src/interpreter/interpreter.cjs

@@ -40,11 +40,14 @@ var __export = (target, all) => {
 var exports_interpreter = {};
 __export(exports_interpreter, {
   Interpreter: () => Interpreter,
+  ExitException: () => ExitException,
   ContinueException: () => ContinueException,
   BreakException: () => BreakException
 });
 module.exports = __toCommonJS(exports_interpreter);
 var import_context = require("./context.cjs");
+var import_lexer = require("../lexer/lexer.cjs");
+var import_parser = require("../parser/parser.cjs");
 var import_stdin = require("../io/stdin.cjs");
 var import_stdout = require("../io/stdout.cjs");
 var import_special_files = require("../fs/special-files.cjs");
@@ -68,6 +71,14 @@ class ContinueException extends Error {
   }
 }
 
+class ExitException extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super("exit");
+    this.exitCode = exitCode;
+  }
+}
+
 class Interpreter {
   fs;
   cwd;
@@ -76,6 +87,9 @@ class Interpreter {
   redirectObjects;
   loopDepth = 0;
   isTTY;
+  argv0;
+  positionalParameters;
+  lastExitCode;
   constructor(options) {
     this.fs = options.fs;
     this.cwd = options.cwd;
@@ -83,6 +97,9 @@ class Interpreter {
     this.commands = options.commands;
     this.redirectObjects = options.redirectObjects ?? {};
     this.isTTY = options.isTTY ?? false;
+    this.argv0 = options.argv0 ?? "sh";
+    this.positionalParameters = [...options.positionalParameters ?? []];
+    this.lastExitCode = options.lastExitCode ?? 0;
   }
   getLoopDepth() {
     return this.loopDepth;
@@ -90,7 +107,16 @@ class Interpreter {
   async execute(ast) {
     const stdout = import_stdout.createStdout(this.isTTY);
     const stderr = import_stdout.createStderr(this.isTTY);
-    const exitCode = await this.executeNode(ast, null, stdout, stderr);
+    let exitCode;
+    try {
+      exitCode = await this.executeNode(ast, null, stdout, stderr);
+    } catch (err) {
+      if (!(err instanceof ExitException)) {
+        throw err;
+      }
+      exitCode = err.exitCode;
+      this.lastExitCode = exitCode;
+    }
     stdout.close();
     stderr.close();
     return {
@@ -100,30 +126,43 @@ class Interpreter {
     };
   }
   async executeNode(node, stdinSource, stdout, stderr) {
+    let exitCode;
     switch (node.type) {
       case "command":
-        return this.executeCommand(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeCommand(node, stdinSource, stdout, stderr);
+        break;
       case "pipeline":
-        return this.executePipeline(node.commands, stdinSource, stdout, stderr);
+        exitCode = await this.executePipeline(node.commands, stdinSource, stdout, stderr);
+        break;
       case "sequence":
-        return this.executeSequence(node.commands, stdinSource, stdout, stderr);
+        exitCode = await this.executeSequence(node.commands, stdinSource, stdout, stderr);
+        break;
       case "and":
-        return this.executeAnd(node.left, node.right, stdinSource, stdout, stderr);
+        exitCode = await this.executeAnd(node.left, node.right, stdinSource, stdout, stderr);
+        break;
       case "or":
-        return this.executeOr(node.left, node.right, stdinSource, stdout, stderr);
+        exitCode = await this.executeOr(node.left, node.right, stdinSource, stdout, stderr);
+        break;
       case "if":
-        return this.executeIf(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeIf(node, stdinSource, stdout, stderr);
+        break;
       case "for":
-        return this.executeFor(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeFor(node, stdinSource, stdout, stderr);
+        break;
       case "while":
-        return this.executeWhile(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeWhile(node, stdinSource, stdout, stderr);
+        break;
       case "until":
-        return this.executeUntil(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeUntil(node, stdinSource, stdout, stderr);
+        break;
       case "case":
-        return this.executeCase(node, stdinSource, stdout, stderr);
+        exitCode = await this.executeCase(node, stdinSource, stdout, stderr);
+        break;
       default:
         throw new Error("Cannot execute unknown node type");
     }
+    this.lastExitCode = exitCode;
+    return exitCode;
   }
   async executeCommand(node, stdinSource, stdout, stderr) {
     const assignmentEnv = { ...this.env };
@@ -171,95 +210,239 @@ class Interpreter {
     if (stdoutToStderr) {
       actualStdout = actualStderr;
     }
-    const command = this.commands[name];
-    if (!command) {
-      await stderr.writeText(`${name}: command not found
+    let exitCode = await this.invokeCommand(name, args, actualStdin, actualStdout, actualStderr, assignmentEnv);
+    if (actualStdout !== stdout) {
+      actualStdout.close();
+    }
+    if (actualStderr !== stderr && actualStderr !== actualStdout) {
+      actualStderr.close();
+    }
+    try {
+      await Promise.all(fileWritePromises);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const writeRedirects = node.redirects.filter((r) => r.mode !== "<" && r.mode !== "2>&1" && r.mode !== "1>&2");
+      const target = writeRedirects.length > 0 ? await this.expandWordScalar(writeRedirects[writeRedirects.length - 1].target, this.env) : "unknown";
+      await stderr.writeText(`sh: ${target}: ${message}
 `);
-      return 127;
+      exitCode = 1;
     }
-    const exec = async (cmdName, cmdArgs) => {
-      const cmd = this.commands[cmdName];
-      if (!cmd) {
-        return {
-          stdout: Buffer.alloc(0),
-          stderr: Buffer.from(`${cmdName}: command not found
-`),
-          exitCode: 127
-        };
+    return exitCode;
+  }
+  async invokeCommand(name, args, stdinSource, stdout, stderr, env) {
+    const command = this.commands[name];
+    if (command) {
+      return this.invokeRegisteredCommand(name, command, args, stdinSource, stdout, stderr, env);
+    }
+    if (name.includes("/")) {
+      return this.executeExecutableFile(name, args, stdinSource, stdout, stderr, env);
+    }
+    await stderr.writeText(`${name}: command not found
+`);
+    return 127;
+  }
+  async invokeRegisteredCommand(name, command, args, stdinSource, stdout, stderr, env) {
+    const exec = this.createExec(env);
+    const shell = this.createShellApi(stdinSource, stdout, stderr, env);
+    const ctx = import_context.createCommandContext({
+      args,
+      stdin: import_stdin.createStdin(stdinSource),
+      stdout,
+      stderr,
+      fs: this.fs,
+      cwd: this.cwd,
+      env,
+      setCwd: (path) => this.setCwd(path),
+      exec,
+      shell
+    });
+    try {
+      return await command(ctx);
+    } catch (err) {
+      if (err instanceof BreakException || err instanceof ContinueException || err instanceof ExitException) {
+        throw err;
       }
+      const message = err instanceof Error ? err.message : String(err);
+      await stderr.writeText(`${name}: ${message}
+`);
+      return 1;
+    }
+  }
+  createExec(env) {
+    return async (name, args) => {
       const subStdout = import_stdout.createStdout();
       const subStderr = import_stdout.createStderr();
-      const subCtx = import_context.createCommandContext({
-        args: cmdArgs,
-        stdin: import_stdin.createStdin(null),
-        stdout: subStdout,
-        stderr: subStderr,
-        fs: this.fs,
-        cwd: this.cwd,
-        env: { ...assignmentEnv },
-        setCwd: (path) => this.setCwd(path),
-        exec
-      });
-      let exitCode2;
-      try {
-        exitCode2 = await cmd(subCtx);
-      } catch (err) {
-        if (err instanceof BreakException || err instanceof ContinueException) {
-          throw err;
-        }
-        const message = err instanceof Error ? err.message : String(err);
-        await subStderr.writeText(`${cmdName}: ${message}
-`);
-        exitCode2 = 1;
-      }
+      const exitCode = await this.invokeCommand(name, args, null, subStdout, subStderr, { ...env });
       subStdout.close();
       subStderr.close();
       return {
         stdout: await subStdout.collect(),
         stderr: await subStderr.collect(),
-        exitCode: exitCode2
+        exitCode
       };
     };
-    const ctx = import_context.createCommandContext({
-      args,
-      stdin: import_stdin.createStdin(actualStdin),
-      stdout: actualStdout,
-      stderr: actualStderr,
+  }
+  createShellApi(stdinSource, stdout, stderr, env) {
+    return {
+      eval: (source) => this.executeSourceInCurrentFrame(source, stdinSource, stdout, stderr, "eval"),
+      source: (path, args = []) => this.sourceFile(path, args, stdinSource, stdout, stderr),
+      runScript: (path, args = []) => this.executeExecutableFile(path, args, stdinSource, stdout, stderr, { ...env }),
+      runShell: (source, options = {}) => this.executeIsolatedShellSource(source, options.argv0 ?? "sh", options.args ?? [], stdinSource, stdout, stderr, env),
+      getLastExitCode: () => this.lastExitCode,
+      exit: (exitCode = this.lastExitCode) => {
+        throw new ExitException(this.normalizeExitCode(exitCode));
+      }
+    };
+  }
+  async executeExecutableFile(pathName, args, stdinSource, stdout, stderr, env) {
+    const loaded = await this.loadScriptSource(pathName, stderr, 127);
+    if (!loaded.ok) {
+      return loaded.exitCode;
+    }
+    const shebang = this.parseShebang(loaded.source);
+    if (!shebang || shebang.command === "sh") {
+      return this.executeIsolatedShellSource(loaded.source, pathName, args, stdinSource, stdout, stderr, env);
+    }
+    const command = this.commands[shebang.command];
+    if (!command) {
+      await stderr.writeText(`${pathName}: unsupported interpreter: ${shebang.display}
+`);
+      return 126;
+    }
+    const child = new Interpreter({
       fs: this.fs,
       cwd: this.cwd,
-      env: assignmentEnv,
-      setCwd: (path) => this.setCwd(path),
-      exec
+      env: { ...env },
+      commands: this.commands,
+      redirectObjects: this.redirectObjects,
+      isTTY: this.isTTY,
+      argv0: shebang.command,
+      positionalParameters: []
+    });
+    return child.invokeRegisteredCommand(shebang.command, command, [...shebang.args, pathName, ...args], stdinSource, stdout, stderr, { ...env });
+  }
+  async sourceFile(pathName, args, stdinSource, stdout, stderr) {
+    const loaded = await this.loadScriptSource(pathName, stderr, 1);
+    if (!loaded.ok) {
+      return loaded.exitCode;
+    }
+    return this.executeSourceInCurrentFrame(loaded.source, stdinSource, stdout, stderr, pathName, args.length > 0 ? { args } : undefined);
+  }
+  async executeIsolatedShellSource(source, argv0, args, stdinSource, stdout, stderr, env) {
+    const interpreter = new Interpreter({
+      fs: this.fs,
+      cwd: this.cwd,
+      env: { ...env },
+      commands: this.commands,
+      redirectObjects: this.redirectObjects,
+      isTTY: this.isTTY,
+      argv0,
+      positionalParameters: args
     });
-    let exitCode;
     try {
-      exitCode = await command(ctx);
+      return await interpreter.executeSourceInCurrentFrame(source, stdinSource, stdout, stderr, argv0);
     } catch (err) {
-      if (err instanceof BreakException || err instanceof ContinueException) {
+      if (err instanceof ExitException) {
+        return err.exitCode;
+      }
+      throw err;
+    }
+  }
+  async executeSourceInCurrentFrame(source, stdinSource, stdout, stderr, errorName, positionalOverride) {
+    const previousArgv0 = this.argv0;
+    const previousPositionals = this.positionalParameters;
+    if (positionalOverride?.argv0 !== undefined) {
+      this.argv0 = positionalOverride.argv0;
+    }
+    if (positionalOverride?.args !== undefined) {
+      this.positionalParameters = [...positionalOverride.args];
+    }
+    try {
+      const ast = this.parseSource(source);
+      if (!ast) {
+        return 0;
+      }
+      return await this.executeNode(ast, stdinSource, stdout, stderr);
+    } catch (err) {
+      if (err instanceof BreakException || err instanceof ContinueException || err instanceof ExitException) {
         throw err;
       }
       const message = err instanceof Error ? err.message : String(err);
-      await stderr.writeText(`${name}: ${message}
+      await stderr.writeText(`${errorName}: ${message}
 `);
-      exitCode = 1;
+      return 2;
+    } finally {
+      if (positionalOverride?.argv0 !== undefined) {
+        this.argv0 = previousArgv0;
+      }
+      if (positionalOverride?.args !== undefined) {
+        this.positionalParameters = previousPositionals;
+      }
     }
-    if (actualStdout !== stdout) {
-      actualStdout.close();
+  }
+  parseSource(source) {
+    const tokens = new import_lexer.Lexer(source, { preserveNewlines: true }).tokenize();
+    if (tokens.every((token) => token.type === "newline" || token.type === "eof")) {
+      return null;
     }
-    if (actualStderr !== stderr && actualStderr !== actualStdout) {
-      actualStderr.close();
+    return new import_parser.Parser(tokens).parse();
+  }
+  async loadScriptSource(pathName, stderr, missingExitCode) {
+    const path = this.fs.resolve(this.cwd, pathName);
+    if (!await this.fs.exists(path)) {
+      await stderr.writeText(`${pathName}: No such file or directory
+`);
+      return { ok: false, exitCode: missingExitCode };
+    }
+    const stat = await this.fs.stat(path);
+    if (stat.isDirectory()) {
+      await stderr.writeText(`${pathName}: is a directory
+`);
+      return { ok: false, exitCode: 126 };
+    }
+    if (!stat.isFile()) {
+      await stderr.writeText(`${pathName}: not a file
+`);
+      return { ok: false, exitCode: 126 };
     }
     try {
-      await Promise.all(fileWritePromises);
+      return { ok: true, path, source: await this.fs.readFile(path, "utf-8") };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const writeRedirects = node.redirects.filter((r) => r.mode !== "<" && r.mode !== "2>&1" && r.mode !== "1>&2");
-      const target = writeRedirects.length > 0 ? await this.expandWordScalar(writeRedirects[writeRedirects.length - 1].target, this.env) : "unknown";
-      await stderr.writeText(`sh: ${target}: ${message}
+      await stderr.writeText(`${pathName}: ${message}
 `);
-      exitCode = 1;
+      return { ok: false, exitCode: 126 };
     }
-    return exitCode;
+  }
+  parseShebang(source) {
+    if (!source.startsWith("#!")) {
+      return null;
+    }
+    const lineEnd = source.indexOf(`
+`);
+    const line = source.slice(2, lineEnd === -1 ? undefined : lineEnd).trim();
+    if (line === "") {
+      return { command: "sh", args: [], display: "sh" };
+    }
+    const parts = line.split(/\s+/);
+    const executable = parts[0];
+    const executableName = this.fs.basename(executable);
+    if (executableName === "env") {
+      const envCommand = parts[1];
+      if (!envCommand) {
+        return { command: "env", args: [], display: line };
+      }
+      return {
+        command: this.fs.basename(envCommand),
+        args: parts.slice(2),
+        display: line
+      };
+    }
+    return {
+      command: executableName,
+      args: parts.slice(1),
+      display: line
+    };
   }
   async handleRedirect(redirect, stdin, stdout, stderr, env) {
     const target = await this.expandWordScalar(redirect.target, env);
@@ -672,6 +855,10 @@ class Interpreter {
         this.appendSegment(fields[fields.length - 1], part.value, part.quoted);
         continue;
       }
+      if (part.type === "variable" && part.name === "@" && part.quoted) {
+        this.appendQuotedPositionalParameters(fields);
+        continue;
+      }
       const value = await this.expandWordPart(part, env);
       if (part.quoted) {
         this.appendSegment(fields[fields.length - 1], value, true);
@@ -695,7 +882,7 @@ class Interpreter {
       case "text":
         return part.value;
       case "variable":
-        return env[part.name] ?? "";
+        return this.getVariableValue(part.name, env);
       case "substitution":
         return this.executeSubstitution(part.command, env);
       case "arithmetic":
@@ -704,6 +891,35 @@ class Interpreter {
         throw new Error("Cannot expand unknown word part");
     }
   }
+  getVariableValue(name, env) {
+    if (name === "0") {
+      return this.argv0;
+    }
+    if (name === "#") {
+      return String(this.positionalParameters.length);
+    }
+    if (name === "?") {
+      return String(this.lastExitCode);
+    }
+    if (name === "*" || name === "@") {
+      return this.positionalParameters.join(" ");
+    }
+    if (/^[1-9]$/.test(name)) {
+      return this.positionalParameters[Number(name) - 1] ?? "";
+    }
+    return env[name] ?? "";
+  }
+  appendQuotedPositionalParameters(fields) {
+    if (this.positionalParameters.length === 0) {
+      return;
+    }
+    this.appendSegment(fields[fields.length - 1], this.positionalParameters[0], true);
+    for (let i = 1;i < this.positionalParameters.length; i++) {
+      const field = this.createExpandedField();
+      this.appendSegment(field, this.positionalParameters[i], true);
+      fields.push(field);
+    }
+  }
   async executeSubstitution(command, env) {
     const interpreter = new Interpreter({
       fs: this.fs,
@@ -711,7 +927,10 @@ class Interpreter {
       env,
       commands: this.commands,
       redirectObjects: this.redirectObjects,
-      isTTY: false
+      isTTY: false,
+      argv0: this.argv0,
+      positionalParameters: this.positionalParameters,
+      lastExitCode: this.lastExitCode
     });
     const result = await interpreter.execute(command);
     return result.stdout.toString("utf-8").replace(/\n+$/, "");
@@ -812,8 +1031,8 @@ class Interpreter {
     expandedExpr = expandedExpr.replace(/\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_, name) => {
       return env[name] ?? "0";
     });
-    expandedExpr = expandedExpr.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, name) => {
-      return env[name] ?? "0";
+    expandedExpr = expandedExpr.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*|[0-9#*@?])/g, (_, name) => {
+      return this.getVariableValue(name, env) || "0";
     });
     expandedExpr = expandedExpr.replace(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g, (match) => {
       if (/^\d+$/.test(match))
@@ -970,6 +1189,12 @@ class Interpreter {
     };
     return parseOr();
   }
+  normalizeExitCode(exitCode) {
+    if (!Number.isFinite(exitCode)) {
+      return 2;
+    }
+    return (Math.trunc(exitCode) % 256 + 256) % 256;
+  }
   setCwd(cwd) {
     this.env.OLDPWD = this.cwd;
     this.cwd = cwd;
@@ -985,4 +1210,4 @@ class Interpreter {
   }
 }
 
-//# debugId=1238E19B5ED5404064756E2164756E21
+//# debugId=48778DC29A4E811364756E2164756E21