shell-dsl 0.0.35 → 0.0.36

package/README.md

@@ -257,7 +257,10 @@ await sh`FOO=bar && echo $FOO`.text();  // "bar\n"
 Assign variables for a single command (scoped):
 
 ```ts
-await sh`FOO=bar echo $FOO`.text();     // "bar\n"
+await sh`FOO=bar echo ok`.text();       // "ok\n"
+await sh`FOO=bar echo $FOO`.text();     // "\n"
+// FOO is available to the executed command via ctx.env,
+// but sibling shell expansion still uses the previous shell env
 // FOO is not set after this command
 ```
 
@@ -326,15 +329,35 @@ const myls: Command = async (ctx) => {
 };
 ```
 
+## Field Splitting
+
+Unquoted parameter, command, and arithmetic expansions follow shell-style word expansion:
+
+1. Expand variables / `$(...)` / `$((...))`
+2. Split unquoted results using `IFS` (default: space, tab, newline)
+3. Apply pathname expansion (globbing) to the resulting fields
+
+Quoted expansions stay single-field, and assignment values plus redirect targets use scalar expansion only.
+
+```ts
+await sh`LIST="alpha beta" && for item in $LIST; do echo $item; done`.text();
+// "alpha\nbeta\n"
+
+await sh`LIST="alpha,beta,,gamma" && IFS=, && for item in $LIST; do echo "[$item]"; done`.text();
+// "[alpha]\n[beta]\n[]\n[gamma]\n"
+```
+
 ## Glob Expansion
 
-Globs are expanded by the interpreter before command execution:
+Globs run after field splitting, and only wildcard characters from unquoted text or unquoted expansions participate:
 
 ```ts
 await sh`ls *.txt`;           // Matches: a.txt, b.txt, ...
 await sh`cat src/**/*.ts`;    // Recursive glob
 await sh`echo file[123].txt`; // Character classes
 await sh`echo {a,b,c}.txt`;   // Brace expansion: a.txt b.txt c.txt
+await sh`pattern='*.txt'; echo $pattern`;   // Expands matches
+await sh`pattern='*.txt'; echo "$pattern"`; // Literal "*.txt"
 ```
 
 ## Command Substitution

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "type": "commonjs"
 }

package/dist/cjs/src/index.cjs

@@ -42,22 +42,17 @@ __export(exports_src, {
   tokenToString: () => import_lexer.tokenToString,
   parse: () => import_parser.parse,
   lex: () => import_lexer.lex,
+  isWordNode: () => import_parser2.isWordNode,
   isWhileNode: () => import_parser2.isWhileNode,
-  isVariableNode: () => import_parser2.isVariableNode,
   isUntilNode: () => import_parser2.isUntilNode,
-  isSubstitutionNode: () => import_parser2.isSubstitutionNode,
   isSequenceNode: () => import_parser2.isSequenceNode,
   isRawValue: () => import_types.isRawValue,
   isPipelineNode: () => import_parser2.isPipelineNode,
   isOrNode: () => import_parser2.isOrNode,
-  isLiteralNode: () => import_parser2.isLiteralNode,
   isIfNode: () => import_parser2.isIfNode,
-  isGlobNode: () => import_parser2.isGlobNode,
   isForNode: () => import_parser2.isForNode,
-  isConcatNode: () => import_parser2.isConcatNode,
   isCommandNode: () => import_parser2.isCommandNode,
   isCaseNode: () => import_parser2.isCaseNode,
-  isArithmeticNode: () => import_parser2.isArithmeticNode,
   isAndNode: () => import_parser2.isAndNode,
   globVirtualFS: () => import_utils.globVirtualFS,
   escapeForInterpolation: () => import_utils.escapeForInterpolation,
@@ -103,4 +98,4 @@ var import_io2 = require("./io/index.cjs");
 var import_utils = require("./utils/index.cjs");
 var import_vcs = require("./vcs/index.cjs");
 
-//# debugId=27F0973A44539CA064756E2164756E21
+//# debugId=188D4F3252D1BB8C64756E2164756E21

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

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../src/index.ts"],
   "sourcesContent": [
-    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  VirtualFSWritable,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n  IfNode,\n  ForNode,\n  WhileNode,\n  UntilNode,\n  CaseNode,\n  CaseClause,\n  ArithmeticNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n  isIfNode,\n  isForNode,\n  isWhileNode,\n  isUntilNode,\n  isCaseNode,\n  isArithmeticNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions, BreakException, ContinueException } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  WebFileSystem,\n  createWebUnderlyingFS,\n  type PathOps,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation, globVirtualFS } from \"./utils/index.cjs\";\nexport type { GlobVirtualFS, GlobOptions } from \"./utils/index.cjs\";\n\n// Version Control\nexport { VersionControlSystem } from \"./vcs/index.cjs\";\nexport type {\n  VCSConfig,\n  VCSAttributeRule,\n  VCSResolvedAttributes,\n  VCSDiffMode,\n  VCSPatchSuppressionReason,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  TreeEntry,\n  FileEntry,\n  DirectoryEntry,\n  VCSIndexEntry,\n  VCSIndexFile,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./vcs/index.cjs\";\n"
+    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  VirtualFSWritable,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  WordNode,\n  WordPart,\n  TextPart,\n  VariablePart,\n  SubstitutionPart,\n  ArithmeticPart,\n  IfNode,\n  ForNode,\n  WhileNode,\n  UntilNode,\n  CaseNode,\n  CaseClause,\n} from \"./parser/index.cjs\";\nexport {\n  isWordNode,\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isIfNode,\n  isForNode,\n  isWhileNode,\n  isUntilNode,\n  isCaseNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions, BreakException, ContinueException } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  WebFileSystem,\n  createWebUnderlyingFS,\n  type PathOps,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation, globVirtualFS } from \"./utils/index.cjs\";\nexport type { GlobVirtualFS, GlobOptions } from \"./utils/index.cjs\";\n\n// Version Control\nexport { VersionControlSystem } from \"./vcs/index.cjs\";\nexport type {\n  VCSConfig,\n  VCSAttributeRule,\n  VCSResolvedAttributes,\n  VCSDiffMode,\n  VCSPatchSuppressionReason,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  TreeEntry,\n  FileEntry,\n  DirectoryEntry,\n  VCSIndexEntry,\n  VCSIndexFile,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./vcs/index.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAiB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AAuCO,IAjBP;AAoBwF,IAAxF;AAGgC,IAAhC;AAUO,IATP;AAYuC,IAAvC;AACwF,IAAxF;AAG8D,IAA9D;AAIqC,IAArC;",
-  "debugId": "27F0973A44539CA064756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAiB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AAkCO,IAZP;AAewF,IAAxF;AAGgC,IAAhC;AAUO,IATP;AAYuC,IAAvC;AACwF,IAAxF;AAG8D,IAA9D;AAIqC,IAArC;",
+  "debugId": "188D4F3252D1BB8C64756E2164756E21",
   "names": []
 }

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

@@ -48,6 +48,9 @@ var import_context = require("./context.cjs");
 var import_stdin = require("../io/stdin.cjs");
 var import_stdout = require("../io/stdout.cjs");
 var import_special_files = require("../fs/special-files.cjs");
+var DEFAULT_IFS = ` 	
+`;
+var GLOB_META_CHARS = /[*?[{]/;
 
 class BreakException extends Error {
   levels;
@@ -119,34 +122,23 @@ class Interpreter {
       case "case":
         return this.executeCase(node, stdinSource, stdout, stderr);
       default:
-        throw new Error(`Cannot execute node type: ${node.type}`);
+        throw new Error("Cannot execute unknown node type");
     }
   }
   async executeCommand(node, stdinSource, stdout, stderr) {
-    const localEnv = { ...this.env };
+    const assignmentEnv = { ...this.env };
     for (const assignment of node.assignments) {
-      localEnv[assignment.name] = await this.evaluateNode(assignment.value);
-    }
-    const name = await this.evaluateNode(node.name);
-    if (name === "" && node.assignments.length > 0) {
-      for (const assignment of node.assignments) {
-        this.env[assignment.name] = await this.evaluateNode(assignment.value);
-      }
-      return 0;
-    }
-    const args = [];
-    for (const arg of node.args) {
-      const evaluated = await this.evaluateNode(arg, localEnv);
-      if (arg.type === "glob") {
-        const matches = await this.fs.glob(evaluated, { cwd: this.cwd });
-        if (matches.length > 0) {
-          args.push(...matches);
-        } else {
-          args.push(evaluated);
+      assignmentEnv[assignment.name] = await this.expandWordScalar(assignment.value, assignmentEnv);
+    }
+    const expandedWords = await this.expandCommandWords(node, this.env);
+    const [name, ...args] = expandedWords;
+    if (name === undefined || name === "") {
+      if (node.assignments.length > 0) {
+        for (const assignment of node.assignments) {
+          this.env[assignment.name] = assignmentEnv[assignment.name] ?? "";
         }
-      } else {
-        args.push(evaluated);
       }
+      return 0;
     }
     let actualStdin = stdinSource;
     let actualStdout = stdout;
@@ -156,7 +148,7 @@ class Interpreter {
     const fileWritePromises = [];
     for (const redirect of node.redirects) {
       try {
-        const result = await this.handleRedirect(redirect, actualStdin, actualStdout, actualStderr);
+        const result = await this.handleRedirect(redirect, actualStdin, actualStdout, actualStderr, this.env);
         actualStdin = result.stdin;
         actualStdout = result.stdout;
         actualStderr = result.stderr;
@@ -166,7 +158,7 @@ class Interpreter {
           fileWritePromises.push(result.fileWritePromise);
         }
       } catch (err) {
-        const target = await this.evaluateNode(redirect.target);
+        const target = await this.expandWordScalar(redirect.target, this.env);
         const message = err instanceof Error ? err.message : String(err);
         await stderr.writeText(`sh: ${target}: ${message}
 `);
@@ -204,7 +196,7 @@ class Interpreter {
         stderr: subStderr,
         fs: this.fs,
         cwd: this.cwd,
-        env: { ...localEnv },
+        env: { ...assignmentEnv },
         setCwd: (path) => this.setCwd(path),
         exec
       });
@@ -235,7 +227,7 @@ class Interpreter {
       stderr: actualStderr,
       fs: this.fs,
       cwd: this.cwd,
-      env: localEnv,
+      env: assignmentEnv,
       setCwd: (path) => this.setCwd(path),
       exec
     });
@@ -262,15 +254,15 @@ class Interpreter {
     } 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.evaluateNode(writeRedirects[writeRedirects.length - 1].target) : "unknown";
+      const target = writeRedirects.length > 0 ? await this.expandWordScalar(writeRedirects[writeRedirects.length - 1].target, this.env) : "unknown";
       await stderr.writeText(`sh: ${target}: ${message}
 `);
       exitCode = 1;
     }
     return exitCode;
   }
-  async handleRedirect(redirect, stdin, stdout, stderr) {
-    const target = await this.evaluateNode(redirect.target);
+  async handleRedirect(redirect, stdin, stdout, stderr, env) {
+    const target = await this.expandWordScalar(redirect.target, env);
     if (target in this.redirectObjects) {
       return this.handleObjectRedirect(redirect.mode, this.redirectObjects[target], stdin, stdout, stderr);
     }
@@ -502,17 +494,7 @@ class Interpreter {
   async executeFor(node, stdinSource, stdout, stderr) {
     const expandedItems = [];
     for (const item of node.items) {
-      const evaluated = await this.evaluateNode(item);
-      if (item.type === "glob") {
-        const matches = await this.fs.glob(evaluated, { cwd: this.cwd });
-        if (matches.length > 0) {
-          expandedItems.push(...matches);
-        } else {
-          expandedItems.push(evaluated);
-        }
-      } else {
-        expandedItems.push(evaluated);
-      }
+      expandedItems.push(...await this.expandWordForCommand(item, this.env));
     }
     if (expandedItems.length === 0) {
       return 0;
@@ -616,10 +598,10 @@ class Interpreter {
     return lastExitCode;
   }
   async executeCase(node, stdinSource, stdout, stderr) {
-    const word = await this.evaluateNode(node.word);
+    const word = await this.expandWordScalar(node.word, this.env);
     for (const clause of node.clauses) {
       for (const patternNode of clause.patterns) {
-        const pattern = await this.evaluateNode(patternNode);
+        const pattern = await this.expandWordScalar(patternNode, this.env);
         if (this.matchCasePattern(word, pattern)) {
           return this.executeNode(clause.body, stdinSource, stdout, stderr);
         }
@@ -660,34 +642,170 @@ class Interpreter {
       return word === pattern;
     }
   }
-  async evaluateNode(node, localEnv) {
-    const env = localEnv ?? this.env;
-    switch (node.type) {
-      case "literal":
-        return node.value;
+  async expandCommandWords(node, env) {
+    const expanded = [];
+    for (const word of [node.name, ...node.args]) {
+      expanded.push(...await this.expandWordForCommand(word, env));
+    }
+    return expanded;
+  }
+  async expandWordForCommand(word, env) {
+    const fields = await this.expandWordFields(word, env);
+    const expanded = [];
+    for (const field of fields) {
+      expanded.push(...await this.expandPathname(field));
+    }
+    return expanded;
+  }
+  async expandWordScalar(word, env) {
+    let result = "";
+    for (const part of word.parts) {
+      result += await this.expandWordPart(part, env);
+    }
+    return result;
+  }
+  async expandWordFields(word, env) {
+    const fields = [this.createExpandedField()];
+    const ifs = this.getIFS(env);
+    for (const part of word.parts) {
+      if (part.type === "text") {
+        this.appendSegment(fields[fields.length - 1], part.value, part.quoted);
+        continue;
+      }
+      const value = await this.expandWordPart(part, env);
+      if (part.quoted) {
+        this.appendSegment(fields[fields.length - 1], value, true);
+        continue;
+      }
+      const splitFields = this.splitUnquotedExpansion(value, ifs);
+      if (splitFields.length === 0) {
+        continue;
+      }
+      this.appendSegment(fields[fields.length - 1], splitFields[0], false);
+      for (let i = 1;i < splitFields.length; i++) {
+        const field = this.createExpandedField();
+        this.appendSegment(field, splitFields[i], false);
+        fields.push(field);
+      }
+    }
+    return fields.filter((field) => field.segments.length > 0);
+  }
+  async expandWordPart(part, env) {
+    switch (part.type) {
+      case "text":
+        return part.value;
       case "variable":
-        return env[node.name] ?? "";
-      case "glob":
-        return node.pattern;
-      case "concat": {
-        const parts = await Promise.all(node.parts.map((p) => this.evaluateNode(p, localEnv)));
-        return parts.join("");
-      }
-      case "substitution": {
-        const subStdout = import_stdout.createStdout();
-        const subStderr = import_stdout.createStderr();
-        await this.executeNode(node.command, null, subStdout, subStderr);
-        subStdout.close();
-        const output = await subStdout.collect();
-        return output.toString("utf-8").replace(/\n+$/, "");
-      }
-      case "arithmetic": {
-        const result = this.evaluateArithmetic(node.expression, env);
-        return String(result);
-      }
+        return env[part.name] ?? "";
+      case "substitution":
+        return this.executeSubstitution(part.command, env);
+      case "arithmetic":
+        return String(this.evaluateArithmetic(part.expression, env));
       default:
-        throw new Error(`Cannot evaluate node type: ${node.type}`);
+        throw new Error("Cannot expand unknown word part");
+    }
+  }
+  async executeSubstitution(command, env) {
+    const interpreter = new Interpreter({
+      fs: this.fs,
+      cwd: this.cwd,
+      env,
+      commands: this.commands,
+      redirectObjects: this.redirectObjects,
+      isTTY: false
+    });
+    const result = await interpreter.execute(command);
+    return result.stdout.toString("utf-8").replace(/\n+$/, "");
+  }
+  getIFS(env) {
+    return env.IFS ?? DEFAULT_IFS;
+  }
+  splitUnquotedExpansion(value, ifs) {
+    if (value.length === 0) {
+      return [];
+    }
+    if (ifs === "") {
+      return [value];
     }
+    const ifsChars = new Set(ifs);
+    const isIfsWhitespace = (char) => ifsChars.has(char) && (char === " " || char === "\t" || char === `
+`);
+    const isIfsNonWhitespace = (char) => ifsChars.has(char) && !isIfsWhitespace(char);
+    const fields = [];
+    let i = 0;
+    while (i < value.length && isIfsWhitespace(value[i])) {
+      i++;
+    }
+    let fieldStart = i;
+    let lastDelimiterWasNonWhitespace = false;
+    while (i < value.length) {
+      const char = value[i];
+      if (isIfsNonWhitespace(char)) {
+        fields.push(value.slice(fieldStart, i));
+        i++;
+        while (i < value.length && isIfsWhitespace(value[i])) {
+          i++;
+        }
+        fieldStart = i;
+        lastDelimiterWasNonWhitespace = true;
+        continue;
+      }
+      if (isIfsWhitespace(char)) {
+        fields.push(value.slice(fieldStart, i));
+        while (i < value.length && isIfsWhitespace(value[i])) {
+          i++;
+        }
+        if (i < value.length && isIfsNonWhitespace(value[i])) {
+          i++;
+          while (i < value.length && isIfsWhitespace(value[i])) {
+            i++;
+          }
+          lastDelimiterWasNonWhitespace = true;
+        } else {
+          lastDelimiterWasNonWhitespace = false;
+        }
+        fieldStart = i;
+        continue;
+      }
+      lastDelimiterWasNonWhitespace = false;
+      i++;
+    }
+    if (fieldStart < value.length) {
+      fields.push(value.slice(fieldStart));
+    } else if (lastDelimiterWasNonWhitespace) {
+      fields.push("");
+    }
+    return fields;
+  }
+  createExpandedField() {
+    return { segments: [] };
+  }
+  appendSegment(field, value, quoted) {
+    const lastSegment = field.segments[field.segments.length - 1];
+    if (lastSegment && lastSegment.quoted === quoted) {
+      lastSegment.value += value;
+      return;
+    }
+    field.segments.push({ value, quoted });
+  }
+  async expandPathname(field) {
+    if (!this.hasUnquotedGlobMeta(field)) {
+      return [this.fieldToString(field)];
+    }
+    const pattern = this.fieldToGlobPattern(field);
+    const matches = await this.fs.glob(pattern, { cwd: this.cwd });
+    return matches.length > 0 ? matches : [this.fieldToString(field)];
+  }
+  hasUnquotedGlobMeta(field) {
+    return field.segments.some((segment) => !segment.quoted && GLOB_META_CHARS.test(segment.value));
+  }
+  fieldToString(field) {
+    return field.segments.map((segment) => segment.value).join("");
+  }
+  fieldToGlobPattern(field) {
+    return field.segments.map((segment) => segment.quoted ? this.escapeLiteralGlobChars(segment.value) : segment.value).join("");
+  }
+  escapeLiteralGlobChars(value) {
+    return value.replaceAll("[", "[[]").replaceAll("]", "[]]").replaceAll("*", "[*]").replaceAll("?", "[?]").replaceAll("{", "[{]").replaceAll("}", "[}]");
   }
   evaluateArithmetic(expression, env) {
     let expandedExpr = expression;
@@ -867,4 +985,4 @@ class Interpreter {
   }
 }
 
-//# debugId=9752A1F1CEADD56864756E2164756E21
+//# debugId=1238E19B5ED5404064756E2164756E21