cvm-server 0.15.0 → 0.15.1

package/main.cjs

@@ -11,31 +11,31 @@ const dotenv = require("dotenv");
 const url = require("url");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 function _interopNamespaceDefault(e2) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  const n2 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e2) {
     for (const k2 in e2) {
       if (k2 !== "default") {
         const d2 = Object.getOwnPropertyDescriptor(e2, k2);
-        Object.defineProperty(n, k2, d2.get ? d2 : {
+        Object.defineProperty(n2, k2, d2.get ? d2 : {
           enumerable: true,
           get: () => e2[k2]
         });
       }
     }
   }
-  n.default = e2;
-  return Object.freeze(n);
+  n2.default = e2;
+  return Object.freeze(n2);
 }
 const s__namespace = /* @__PURE__ */ _interopNamespaceDefault(s$1);
 const b__namespace = /* @__PURE__ */ _interopNamespaceDefault(b$2);
 const r__namespace = /* @__PURE__ */ _interopNamespaceDefault(r);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var o$1 = Object.defineProperty;
-var I = (e2, t2, n) => t2 in e2 ? o$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: n }) : e2[t2] = n;
-var _$1 = (e2, t2, n) => I(e2, typeof t2 != "symbol" ? t2 + "" : t2, n);
-var i$2 = /* @__PURE__ */ ((e2) => (e2.PUSH = "PUSH", e2.PUSH_UNDEFINED = "PUSH_UNDEFINED", e2.POP = "POP", e2.DUP = "DUP", e2.DUP2 = "DUP2", e2.SWAP = "SWAP", e2.LOAD = "LOAD", e2.STORE = "STORE", e2.CONCAT = "CONCAT", e2.ARRAY_NEW = "ARRAY_NEW", e2.ARRAY_PUSH = "ARRAY_PUSH", e2.ARRAY_GET = "ARRAY_GET", e2.ARRAY_SET = "ARRAY_SET", e2.ARRAY_LEN = "ARRAY_LEN", e2.ARRAY_MAP_PROP = "ARRAY_MAP_PROP", e2.ARRAY_FILTER_PROP = "ARRAY_FILTER_PROP", e2.ARRAY_SLICE = "ARRAY_SLICE", e2.ARRAY_JOIN = "ARRAY_JOIN", e2.ARRAY_INDEX_OF = "ARRAY_INDEX_OF", e2.STRING_LEN = "STRING_LEN", e2.STRING_SUBSTRING = "STRING_SUBSTRING", e2.STRING_INDEXOF = "STRING_INDEXOF", e2.STRING_SPLIT = "STRING_SPLIT", e2.STRING_SLICE = "STRING_SLICE", e2.STRING_CHARAT = "STRING_CHARAT", e2.STRING_TOUPPERCASE = "STRING_TOUPPERCASE", e2.STRING_TOLOWERCASE = "STRING_TOLOWERCASE", e2.STRING_INCLUDES = "STRING_INCLUDES", e2.STRING_ENDS_WITH = "STRING_ENDS_WITH", e2.STRING_STARTS_WITH = "STRING_STARTS_WITH", e2.STRING_TRIM = "STRING_TRIM", e2.STRING_TRIM_START = "STRING_TRIM_START", e2.STRING_TRIM_END = "STRING_TRIM_END", e2.STRING_REPLACE = "STRING_REPLACE", e2.STRING_REPLACE_ALL = "STRING_REPLACE_ALL", e2.STRING_LAST_INDEX_OF = "STRING_LAST_INDEX_OF", e2.STRING_REPEAT = "STRING_REPEAT", e2.STRING_PAD_START = "STRING_PAD_START", e2.STRING_PAD_END = "STRING_PAD_END", e2.LOAD_REGEX = "LOAD_REGEX", e2.REGEX_TEST = "REGEX_TEST", e2.STRING_MATCH = "STRING_MATCH", e2.STRING_REPLACE_REGEX = "STRING_REPLACE_REGEX", e2.LENGTH = "LENGTH", e2.TO_STRING = "TO_STRING", e2.JSON_PARSE = "JSON_PARSE", e2.TYPEOF = "TYPEOF", e2.ADD = "ADD", e2.SUB = "SUB", e2.MUL = "MUL", e2.DIV = "DIV", e2.MOD = "MOD", e2.UNARY_MINUS = "UNARY_MINUS", e2.UNARY_PLUS = "UNARY_PLUS", e2.INC = "INC", e2.DEC = "DEC", e2.EQ = "EQ", e2.NEQ = "NEQ", e2.LT = "LT", e2.GT = "GT", e2.LTE = "LTE", e2.GTE = "GTE", e2.EQ_STRICT = "EQ_STRICT", e2.NEQ_STRICT = "NEQ_STRICT", e2.JUMP = "JUMP", e2.JUMP_IF = "JUMP_IF", e2.JUMP_IF_FALSE = "JUMP_IF_FALSE", e2.JUMP_IF_TRUE = "JUMP_IF_TRUE", e2.CALL = "CALL", e2.RETURN = "RETURN", e2.AND = "AND", e2.OR = "OR", e2.NOT = "NOT", e2.BREAK = "BREAK", e2.CONTINUE = "CONTINUE", e2.ITER_START = "ITER_START", e2.ITER_NEXT = "ITER_NEXT", e2.ITER_END = "ITER_END", e2.OBJECT_ITER_START = "OBJECT_ITER_START", e2.OBJECT_ITER_NEXT = "OBJECT_ITER_NEXT", e2.FS_LIST_FILES = "FS_LIST_FILES", e2.FS_READ_FILE = "FS_READ_FILE", e2.FS_WRITE_FILE = "FS_WRITE_FILE", e2.OBJECT_CREATE = "OBJECT_CREATE", e2.PROPERTY_GET = "PROPERTY_GET", e2.PROPERTY_SET = "PROPERTY_SET", e2.OBJECT_KEYS = "OBJECT_KEYS", e2.JSON_STRINGIFY = "JSON_STRINGIFY", e2.GET = "GET", e2.SET = "SET", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(i$2 || {});
+var f$3 = Object.defineProperty;
+var I = (e2, t2, i2) => t2 in e2 ? f$3(e2, t2, { enumerable: true, configurable: true, writable: true, value: i2 }) : e2[t2] = i2;
+var _$1 = (e2, t2, i2) => I(e2, typeof t2 != "symbol" ? t2 + "" : t2, i2);
+var n = /* @__PURE__ */ ((e2) => (e2.PUSH = "PUSH", e2.PUSH_UNDEFINED = "PUSH_UNDEFINED", e2.POP = "POP", e2.DUP = "DUP", e2.DUP2 = "DUP2", e2.SWAP = "SWAP", e2.LOAD = "LOAD", e2.STORE = "STORE", e2.CONCAT = "CONCAT", e2.ARRAY_NEW = "ARRAY_NEW", e2.ARRAY_PUSH = "ARRAY_PUSH", e2.ARRAY_GET = "ARRAY_GET", e2.ARRAY_SET = "ARRAY_SET", e2.ARRAY_LEN = "ARRAY_LEN", e2.ARRAY_MAP_PROP = "ARRAY_MAP_PROP", e2.ARRAY_FILTER_PROP = "ARRAY_FILTER_PROP", e2.ARRAY_SLICE = "ARRAY_SLICE", e2.ARRAY_JOIN = "ARRAY_JOIN", e2.ARRAY_INDEX_OF = "ARRAY_INDEX_OF", e2.STRING_LEN = "STRING_LEN", e2.STRING_SUBSTRING = "STRING_SUBSTRING", e2.STRING_INDEXOF = "STRING_INDEXOF", e2.STRING_SPLIT = "STRING_SPLIT", e2.STRING_SLICE = "STRING_SLICE", e2.STRING_CHARAT = "STRING_CHARAT", e2.STRING_TOUPPERCASE = "STRING_TOUPPERCASE", e2.STRING_TOLOWERCASE = "STRING_TOLOWERCASE", e2.STRING_INCLUDES = "STRING_INCLUDES", e2.STRING_ENDS_WITH = "STRING_ENDS_WITH", e2.STRING_STARTS_WITH = "STRING_STARTS_WITH", e2.STRING_TRIM = "STRING_TRIM", e2.STRING_TRIM_START = "STRING_TRIM_START", e2.STRING_TRIM_END = "STRING_TRIM_END", e2.STRING_REPLACE = "STRING_REPLACE", e2.STRING_REPLACE_ALL = "STRING_REPLACE_ALL", e2.STRING_LAST_INDEX_OF = "STRING_LAST_INDEX_OF", e2.STRING_REPEAT = "STRING_REPEAT", e2.STRING_PAD_START = "STRING_PAD_START", e2.STRING_PAD_END = "STRING_PAD_END", e2.LOAD_REGEX = "LOAD_REGEX", e2.REGEX_TEST = "REGEX_TEST", e2.STRING_MATCH = "STRING_MATCH", e2.STRING_REPLACE_REGEX = "STRING_REPLACE_REGEX", e2.LENGTH = "LENGTH", e2.TO_STRING = "TO_STRING", e2.JSON_PARSE = "JSON_PARSE", e2.TYPEOF = "TYPEOF", e2.ADD = "ADD", e2.SUB = "SUB", e2.MUL = "MUL", e2.DIV = "DIV", e2.MOD = "MOD", e2.UNARY_MINUS = "UNARY_MINUS", e2.UNARY_PLUS = "UNARY_PLUS", e2.INC = "INC", e2.DEC = "DEC", e2.EQ = "EQ", e2.NEQ = "NEQ", e2.LT = "LT", e2.GT = "GT", e2.LTE = "LTE", e2.GTE = "GTE", e2.EQ_STRICT = "EQ_STRICT", e2.NEQ_STRICT = "NEQ_STRICT", e2.JUMP = "JUMP", e2.JUMP_IF = "JUMP_IF", e2.JUMP_IF_FALSE = "JUMP_IF_FALSE", e2.JUMP_IF_TRUE = "JUMP_IF_TRUE", e2.CALL = "CALL", e2.RETURN = "RETURN", e2.AND = "AND", e2.OR = "OR", e2.NOT = "NOT", e2.BREAK = "BREAK", e2.CONTINUE = "CONTINUE", e2.ITER_START = "ITER_START", e2.ITER_NEXT = "ITER_NEXT", e2.ITER_END = "ITER_END", e2.OBJECT_ITER_START = "OBJECT_ITER_START", e2.OBJECT_ITER_NEXT = "OBJECT_ITER_NEXT", e2.FS_LIST_FILES = "FS_LIST_FILES", e2.FS_READ_FILE = "FS_READ_FILE", e2.FS_WRITE_FILE = "FS_WRITE_FILE", e2.OBJECT_CREATE = "OBJECT_CREATE", e2.PROPERTY_GET = "PROPERTY_GET", e2.PROPERTY_SET = "PROPERTY_SET", e2.OBJECT_KEYS = "OBJECT_KEYS", e2.JSON_STRINGIFY = "JSON_STRINGIFY", e2.GET = "GET", e2.SET = "SET", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(n || {});
 function A$1(e2) {
-  const t2 = [], n = [];
+  const t2 = [], i2 = [];
   let r2 = false;
   const a2 = s__namespace.createSourceFile(
     "program.ts",
@@ -43,15 +43,15 @@ function A$1(e2) {
     s__namespace.ScriptTarget.Latest,
     true
   );
-  function m2(T) {
-    if (s__namespace.isFunctionDeclaration(T) && T.name && T.name.text === "main" && (r2 = true, T.parameters.length > 0 && t2.push("main() must not have parameters")), s__namespace.isCallExpression(T) && s__namespace.isIdentifier(T.expression)) {
-      const l = T.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(l) && t2.push(`Unsupported function: ${l}`);
+  function T(S) {
+    if (s__namespace.isFunctionDeclaration(S) && S.name && S.name.text === "main" && (r2 = true, S.parameters.length > 0 && t2.push("main() must not have parameters")), s__namespace.isCallExpression(S) && s__namespace.isIdentifier(S.expression)) {
+      const c2 = S.expression.text;
+      ["setTimeout", "fetch", "require", "import"].includes(c2) && t2.push(`Unsupported function: ${c2}`);
     }
-    s__namespace.forEachChild(T, m2);
+    s__namespace.forEachChild(S, T);
   }
-  return m2(a2), r2 || t2.push("Program must have a main() function"), t2.length === 0 && n.push({ op: i$2.HALT }), {
-    bytecode: n,
+  return T(a2), r2 || t2.push("Program must have a main() function"), t2.length === 0 && i2.push({ op: n.HALT }), {
+    bytecode: i2,
     errors: t2,
     hasMain: r2
   };
@@ -65,9 +65,9 @@ class g {
   /**
    * Emit an instruction and return its index
    */
-  emit(t2, n) {
+  emit(t2, i2) {
     const r2 = this.bytecode.length;
-    return this.bytecode.push({ op: t2, arg: n }), r2;
+    return this.bytecode.push({ op: t2, arg: i2 }), r2;
   }
   /**
    * Get the current address (next instruction index)
@@ -78,14 +78,14 @@ class g {
   /**
    * Patch a jump instruction with the target address
    */
-  patchJump(t2, n) {
-    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = n);
+  patchJump(t2, i2) {
+    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = i2);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(t2, n) {
-    t2.forEach((r2) => this.patchJump(r2, n));
+  patchJumps(t2, i2) {
+    t2.forEach((r2) => this.patchJump(r2, i2));
   }
   /**
    * Push a new jump context onto the stack
@@ -110,9 +110,9 @@ class g {
    */
   findLoopContext() {
     for (let t2 = this.contextStack.length - 1; t2 >= 0; t2--) {
-      const n = this.contextStack[t2];
-      if (n.type === "loop" || n.type === "foreach")
-        return n;
+      const i2 = this.contextStack[t2];
+      if (i2.type === "loop" || i2.type === "foreach")
+        return i2;
     }
     return null;
   }
@@ -141,224 +141,226 @@ class g {
     return `__temp${this.tempVarCounter++}`;
   }
 }
-const P = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
-  n(e2.expression);
-  const a2 = t2.emit(i$2.JUMP_IF_FALSE, -1), m2 = {
+const P = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  i2(e2.expression);
+  const a2 = t2.emit(n.JUMP_IF_FALSE, -1), T = {
     type: "if",
     endTargets: []
   };
-  if (e2.elseStatement ? m2.elseTarget = a2 : m2.endTargets.push(a2), t2.pushContext(m2), r2(e2.thenStatement), e2.elseStatement) {
-    const l = t2.emit(i$2.JUMP, -1);
-    m2.endTargets.push(l);
-    const S = t2.currentAddress();
-    t2.patchJump(a2, S), r2(e2.elseStatement);
-  }
-  const T = t2.popContext();
-  if (T) {
-    const l = t2.currentAddress();
-    t2.patchJumps(T.endTargets, l);
-  }
-}, N = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  if (e2.elseStatement ? T.elseTarget = a2 : T.endTargets.push(a2), t2.pushContext(T), r2(e2.thenStatement), e2.elseStatement) {
+    const c2 = t2.emit(n.JUMP, -1);
+    T.endTargets.push(c2);
+    const m2 = t2.currentAddress();
+    t2.patchJump(a2, m2), r2(e2.elseStatement);
+  }
+  const S = t2.popContext();
+  if (S) {
+    const c2 = t2.currentAddress();
+    t2.patchJumps(S.endTargets, c2);
+  }
+}, N = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
   const a2 = t2.currentAddress();
-  n(e2.expression);
-  const T = {
+  i2(e2.expression);
+  const S = {
     type: "loop",
-    breakTargets: [t2.emit(i$2.JUMP_IF_FALSE, -1)],
+    breakTargets: [t2.emit(n.JUMP_IF_FALSE, -1)],
     continueTargets: [],
     endTargets: [],
     startAddress: a2
   };
-  t2.pushContext(T), r2(e2.statement), t2.emit(i$2.JUMP, a2);
-  const l = t2.popContext();
-  if (l) {
-    const S = t2.currentAddress();
-    t2.patchJumps(l.breakTargets || [], S);
+  t2.pushContext(S), r2(e2.statement), t2.emit(n.JUMP, a2);
+  const c2 = t2.popContext();
+  if (c2) {
+    const m2 = t2.currentAddress();
+    t2.patchJumps(c2.breakTargets || [], m2), t2.patchJumps(c2.continueTargets || [], a2);
   }
-}, h$1 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
-  const a2 = e2.initializer, m2 = e2.expression;
-  let T;
+}, h$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  const a2 = e2.initializer, T = e2.expression;
+  let S;
   if (s__namespace.isVariableDeclarationList(a2))
-    T = a2.declarations[0].name.getText();
+    S = a2.declarations[0].name.getText();
   else if (s__namespace.isIdentifier(a2))
-    T = a2.text;
+    S = a2.text;
   else
     throw new Error("Unsupported for-of variable declaration");
-  n(m2), t2.emit(i$2.ITER_START);
-  const l = t2.currentAddress();
-  t2.emit(i$2.ITER_NEXT);
-  const S = t2.emit(i$2.JUMP_IF_FALSE, -1);
-  t2.emit(i$2.STORE, T);
+  i2(T), t2.emit(n.ITER_START);
+  const c2 = t2.currentAddress();
+  t2.emit(n.ITER_NEXT);
+  const m2 = t2.emit(n.JUMP_IF_FALSE, -1);
+  t2.emit(n.STORE, S);
   const u2 = {
     type: "foreach",
-    breakTargets: [S],
+    breakTargets: [m2],
     continueTargets: [],
     endTargets: [],
-    startAddress: l,
-    iterVariable: T
+    startAddress: c2,
+    iterVariable: S
   };
-  t2.pushContext(u2), r2(e2.statement), t2.emit(i$2.JUMP, l);
-  const c2 = t2.popContext();
-  if (c2) {
+  t2.pushContext(u2), r2(e2.statement), t2.emit(n.JUMP, c2);
+  const l = t2.popContext();
+  if (l) {
     const R = t2.currentAddress();
-    t2.patchJumps(c2.breakTargets || [], R), t2.emit(i$2.ITER_END);
+    t2.patchJumps(l.breakTargets || [], R), t2.patchJumps(l.continueTargets || [], c2), t2.emit(n.ITER_END);
   }
-}, p$2 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
-  const a2 = e2.initializer, m2 = e2.expression;
-  let T;
+}, p$2 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  const a2 = e2.initializer, T = e2.expression;
+  let S;
   if (s__namespace.isVariableDeclarationList(a2))
-    T = a2.declarations[0].name.getText();
+    S = a2.declarations[0].name.getText();
   else if (s__namespace.isIdentifier(a2))
-    T = a2.text;
+    S = a2.text;
   else
     throw new Error("Unsupported for-in variable declaration");
-  n(m2), t2.emit(i$2.OBJECT_ITER_START);
-  const l = t2.currentAddress();
-  t2.emit(i$2.OBJECT_ITER_NEXT);
-  const S = t2.emit(i$2.JUMP_IF_FALSE, -1);
-  t2.emit(i$2.STORE, T);
+  i2(T), t2.emit(n.OBJECT_ITER_START);
+  const c2 = t2.currentAddress();
+  t2.emit(n.OBJECT_ITER_NEXT);
+  const m2 = t2.emit(n.JUMP_IF_FALSE, -1);
+  t2.emit(n.STORE, S);
   const u2 = {
     type: "foreach",
-    breakTargets: [S],
+    breakTargets: [m2],
     continueTargets: [],
     endTargets: [],
-    startAddress: l,
-    iterVariable: T
+    startAddress: c2,
+    iterVariable: S
   };
-  t2.pushContext(u2), r2(e2.statement), t2.emit(i$2.JUMP, l);
-  const c2 = t2.popContext();
-  if (c2) {
+  t2.pushContext(u2), r2(e2.statement), t2.emit(n.JUMP, c2);
+  const l = t2.popContext();
+  if (l) {
     const R = t2.currentAddress();
-    t2.patchJumps(c2.breakTargets || [], R), t2.emit(i$2.ITER_END);
+    t2.patchJumps(l.breakTargets || [], R), t2.patchJumps(l.continueTargets || [], c2), t2.emit(n.ITER_END);
   }
-}, U = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+}, U = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
   if (e2.initializer)
     if (s__namespace.isVariableDeclarationList(e2.initializer))
-      for (const S of e2.initializer.declarations)
-        S.initializer && (n(S.initializer), t2.emit(i$2.STORE, S.name.getText()));
+      for (const u2 of e2.initializer.declarations)
+        u2.initializer && (i2(u2.initializer), t2.emit(n.STORE, u2.name.getText()));
     else
-      n(e2.initializer), t2.emit(i$2.POP);
+      i2(e2.initializer), t2.emit(n.POP);
   const a2 = t2.currentAddress();
-  let m2;
-  e2.condition && (n(e2.condition), m2 = t2.emit(i$2.JUMP_IF_FALSE, -1));
-  const T = {
+  let T;
+  e2.condition && (i2(e2.condition), T = t2.emit(n.JUMP_IF_FALSE, -1));
+  const S = {
     type: "loop",
-    breakTargets: m2 ? [m2] : [],
+    breakTargets: T ? [T] : [],
     continueTargets: [],
     endTargets: [],
     startAddress: a2
   };
-  t2.pushContext(T), r2(e2.statement), e2.incrementor && (n(e2.incrementor), t2.emit(i$2.POP)), t2.emit(i$2.JUMP, a2);
-  const l = t2.popContext();
-  if (l) {
-    const S = t2.currentAddress();
-    t2.patchJumps(l.breakTargets || [], S);
-  }
-}, y$1 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  t2.pushContext(S), r2(e2.statement);
+  const c2 = t2.currentAddress();
+  e2.incrementor && (i2(e2.incrementor), t2.emit(n.POP)), t2.emit(n.JUMP, a2);
+  const m2 = t2.popContext();
+  if (m2) {
+    const u2 = t2.currentAddress();
+    t2.patchJumps(m2.breakTargets || [], u2), t2.patchJumps(m2.continueTargets || [], c2);
+  }
+}, y$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
   const a2 = t2.generateTempVar();
-  n(e2.expression), t2.emit(i$2.STORE, a2);
-  const m2 = [], T = [];
-  let l = null;
-  if (e2.caseBlock.clauses.forEach((c2, R) => {
-    if (s__namespace.isCaseClause(c2)) {
-      t2.emit(i$2.LOAD, a2), n(c2.expression), t2.emit(i$2.EQ_STRICT);
-      const E2 = t2.emit(i$2.JUMP_IF_TRUE, -1);
-      T.push(E2);
-    } else s__namespace.isDefaultClause(c2) && (l = t2.emit(i$2.JUMP, -1));
-  }), l === null) {
-    const c2 = t2.emit(i$2.JUMP, -1);
-    m2.push(c2);
-  }
-  let S = 0;
-  e2.caseBlock.clauses.forEach((c2, R) => {
-    if (s__namespace.isCaseClause(c2)) {
+  i2(e2.expression), t2.emit(n.STORE, a2);
+  const T = [], S = [];
+  let c2 = null;
+  if (e2.caseBlock.clauses.forEach((l, R) => {
+    if (s__namespace.isCaseClause(l)) {
+      t2.emit(n.LOAD, a2), i2(l.expression), t2.emit(n.EQ_STRICT);
+      const E2 = t2.emit(n.JUMP_IF_TRUE, -1);
+      S.push(E2);
+    } else s__namespace.isDefaultClause(l) && (c2 = t2.emit(n.JUMP, -1));
+  }), c2 === null) {
+    const l = t2.emit(n.JUMP, -1);
+    T.push(l);
+  }
+  let m2 = 0;
+  e2.caseBlock.clauses.forEach((l, R) => {
+    if (s__namespace.isCaseClause(l)) {
       const E2 = t2.currentAddress();
-      t2.patchJumps([T[S]], E2), S++, c2.statements.forEach((x2) => {
+      t2.patchJumps([S[m2]], E2), m2++, l.statements.forEach((x2) => {
         if (s__namespace.isBreakStatement(x2)) {
-          const f3 = t2.emit(i$2.JUMP, -1);
-          m2.push(f3);
+          const o2 = t2.emit(n.JUMP, -1);
+          T.push(o2);
         } else
           r2(x2);
       });
-    } else if (s__namespace.isDefaultClause(c2)) {
+    } else if (s__namespace.isDefaultClause(l)) {
       const E2 = t2.currentAddress();
-      l !== null && t2.patchJumps([l], E2), c2.statements.forEach((x2) => {
+      c2 !== null && t2.patchJumps([c2], E2), l.statements.forEach((x2) => {
         if (s__namespace.isBreakStatement(x2)) {
-          const f3 = t2.emit(i$2.JUMP, -1);
-          m2.push(f3);
+          const o2 = t2.emit(n.JUMP, -1);
+          T.push(o2);
         } else
           r2(x2);
       });
     }
   });
   const u2 = t2.currentAddress();
-  t2.patchJumps(m2, u2);
-}, L = (e2, t2, { compileStatement: n }) => {
+  t2.patchJumps(T, u2);
+}, L = (e2, t2, { compileStatement: i2 }) => {
   e2.statements.forEach((r2) => {
-    n(r2);
+    i2(r2);
   });
-}, k = (e2, t2, { compileExpression: n }) => {
+}, k = (e2, t2, { compileExpression: i2 }) => {
   const r2 = e2.declarationList.declarations[0];
-  r2.initializer && (n(r2.initializer), t2.emit(i$2.STORE, r2.name.getText()));
-}, G = (e2, t2, { compileExpression: n }) => {
+  r2.initializer && (i2(r2.initializer), t2.emit(n.STORE, r2.name.getText()));
+}, G = (e2, t2, { compileExpression: i2 }) => {
   const r2 = e2.expression;
   if (s__namespace.isBinaryExpression(r2)) {
     const a2 = r2.operatorToken.kind;
     if (a2 === s__namespace.SyntaxKind.PlusEqualsToken || a2 === s__namespace.SyntaxKind.MinusEqualsToken || a2 === s__namespace.SyntaxKind.AsteriskEqualsToken || a2 === s__namespace.SyntaxKind.SlashEqualsToken || a2 === s__namespace.SyntaxKind.PercentEqualsToken) {
       if (s__namespace.isIdentifier(r2.left)) {
-        switch (t2.emit(i$2.LOAD, r2.left.text), n(r2.right), a2) {
+        switch (t2.emit(n.LOAD, r2.left.text), i2(r2.right), a2) {
           case s__namespace.SyntaxKind.PlusEqualsToken:
-            t2.emit(i$2.ADD);
+            t2.emit(n.ADD);
             break;
           case s__namespace.SyntaxKind.MinusEqualsToken:
-            t2.emit(i$2.SUB);
+            t2.emit(n.SUB);
             break;
           case s__namespace.SyntaxKind.AsteriskEqualsToken:
-            t2.emit(i$2.MUL);
+            t2.emit(n.MUL);
             break;
           case s__namespace.SyntaxKind.SlashEqualsToken:
-            t2.emit(i$2.DIV);
+            t2.emit(n.DIV);
             break;
           case s__namespace.SyntaxKind.PercentEqualsToken:
-            t2.emit(i$2.MOD);
+            t2.emit(n.MOD);
             break;
         }
-        t2.emit(i$2.STORE, r2.left.text);
+        t2.emit(n.STORE, r2.left.text);
       } else if (s__namespace.isElementAccessExpression(r2.left))
         throw new Error("Compound assignment to array elements not yet supported");
       return;
     } else if (a2 === s__namespace.SyntaxKind.EqualsToken) {
-      if (n(r2.right), s__namespace.isIdentifier(r2.left))
-        t2.emit(i$2.STORE, r2.left.text);
+      if (i2(r2.right), s__namespace.isIdentifier(r2.left))
+        t2.emit(n.STORE, r2.left.text);
       else if (s__namespace.isElementAccessExpression(r2.left)) {
-        const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(i$2.STORE, m2), n(r2.left.expression), n(r2.left.argumentExpression), t2.emit(i$2.LOAD, m2), t2.emit(i$2.ARRAY_SET), t2.emit(i$2.POP);
+        const T = `__temp_${t2.getBytecode().length}`;
+        t2.emit(n.STORE, T), i2(r2.left.expression), i2(r2.left.argumentExpression), t2.emit(n.LOAD, T), t2.emit(n.ARRAY_SET), t2.emit(n.POP);
       } else if (s__namespace.isPropertyAccessExpression(r2.left)) {
-        const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(i$2.STORE, m2), n(r2.left.expression), t2.emit(i$2.PUSH, r2.left.name.text), t2.emit(i$2.LOAD, m2), t2.emit(i$2.PROPERTY_SET), t2.emit(i$2.POP);
+        const T = `__temp_${t2.getBytecode().length}`;
+        t2.emit(n.STORE, T), i2(r2.left.expression), t2.emit(n.PUSH, r2.left.name.text), t2.emit(n.LOAD, T), t2.emit(n.PROPERTY_SET), t2.emit(n.POP);
       }
       return;
     }
   }
   s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.arguments.forEach((a2) => {
-    n(a2);
-  }), t2.emit(i$2.PRINT)) : s__namespace.isCallExpression(r2) && s__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && n(r2.arguments[0]), t2.emit(i$2.CC), t2.emit(i$2.POP)) : s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (n(r2.expression.expression), r2.arguments.length > 0 && n(r2.arguments[0]), t2.emit(i$2.ARRAY_PUSH)) : (s__namespace.isPostfixUnaryExpression(r2) || s__namespace.isPrefixUnaryExpression(r2), n(r2), t2.emit(i$2.POP));
-}, D = (e2, t2, { compileExpression: n }) => {
-  e2.expression ? n(e2.expression) : t2.emit(i$2.PUSH, null), t2.emit(i$2.RETURN);
-}, F$1 = (e2, t2, n) => {
+    i2(a2);
+  }), t2.emit(n.PRINT)) : s__namespace.isCallExpression(r2) && s__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(n.CC), t2.emit(n.POP)) : s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (i2(r2.expression.expression), r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(n.ARRAY_PUSH)) : (s__namespace.isPostfixUnaryExpression(r2) || s__namespace.isPrefixUnaryExpression(r2), i2(r2), t2.emit(n.POP));
+}, D = (e2, t2, { compileExpression: i2 }) => {
+  e2.expression ? i2(e2.expression) : t2.emit(n.PUSH, null), t2.emit(n.RETURN);
+}, F$1 = (e2, t2, i2) => {
   const r2 = t2.findLoopContext();
   if (r2) {
-    r2.type === "foreach" && t2.emit(i$2.ITER_END);
-    const a2 = t2.emit(i$2.BREAK, -1);
+    r2.type === "foreach" && t2.emit(n.ITER_END);
+    const a2 = t2.emit(n.BREAK, -1);
     r2.breakTargets = r2.breakTargets || [], r2.breakTargets.push(a2);
   } else
-    n.reportError(e2, "break statement not in loop");
-}, b$1 = (e2, t2, n) => {
+    i2.reportError(e2, "break statement not in loop");
+}, b$1 = (e2, t2, i2) => {
   const r2 = t2.findLoopContext();
   if (r2 && r2.startAddress !== void 0) {
-    const a2 = t2.emit(i$2.CONTINUE, r2.startAddress);
+    const a2 = t2.emit(n.CONTINUE, -1);
     r2.continueTargets = r2.continueTargets || [], r2.continueTargets.push(a2);
   } else
-    n.reportError(e2, "continue statement not in loop");
+    i2.reportError(e2, "continue statement not in loop");
 }, K = {
   [s__namespace.SyntaxKind.IfStatement]: P,
   [s__namespace.SyntaxKind.WhileStatement]: N,
@@ -372,206 +374,206 @@ const P = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
   [s__namespace.SyntaxKind.ReturnStatement]: D,
   [s__namespace.SyntaxKind.BreakStatement]: F$1,
   [s__namespace.SyntaxKind.ContinueStatement]: b$1
-}, H = (e2, t2, n) => {
-  t2.emit(i$2.PUSH, e2.text);
-}, J = (e2, t2, n) => {
-  t2.emit(i$2.PUSH, Number(e2.text));
-}, M$2 = (e2, t2, n) => {
-  t2.emit(i$2.PUSH, true);
-}, Y = (e2, t2, n) => {
-  t2.emit(i$2.PUSH, false);
-}, C$2 = (e2, t2, n) => {
-  t2.emit(i$2.PUSH, null);
-}, B$1 = (e2, t2, n) => {
-  const r2 = e2.text, a2 = r2.lastIndexOf("/"), m2 = r2.substring(1, a2), T = r2.substring(a2 + 1);
-  t2.emit(i$2.LOAD_REGEX, { pattern: m2, flags: T });
-}, w$1 = (e2, t2, n) => {
-  e2.text === "undefined" ? t2.emit(i$2.PUSH_UNDEFINED) : t2.emit(i$2.LOAD, e2.text);
-}, q = (e2, t2, { compileExpression: n }) => {
-  t2.emit(i$2.ARRAY_NEW), e2.elements.forEach((r2) => {
-    n(r2), t2.emit(i$2.ARRAY_PUSH);
+}, J = (e2, t2, i2) => {
+  t2.emit(n.PUSH, e2.text);
+}, H = (e2, t2, i2) => {
+  t2.emit(n.PUSH, Number(e2.text));
+}, M$2 = (e2, t2, i2) => {
+  t2.emit(n.PUSH, true);
+}, Y = (e2, t2, i2) => {
+  t2.emit(n.PUSH, false);
+}, B$1 = (e2, t2, i2) => {
+  t2.emit(n.PUSH, null);
+}, C$2 = (e2, t2, i2) => {
+  const r2 = e2.text, a2 = r2.lastIndexOf("/"), T = r2.substring(1, a2), S = r2.substring(a2 + 1);
+  t2.emit(n.LOAD_REGEX, { pattern: T, flags: S });
+}, w$1 = (e2, t2, i2) => {
+  e2.text === "undefined" ? t2.emit(n.PUSH_UNDEFINED) : t2.emit(n.LOAD, e2.text);
+}, q = (e2, t2, { compileExpression: i2 }) => {
+  t2.emit(n.ARRAY_NEW), e2.elements.forEach((r2) => {
+    i2(r2), t2.emit(n.ARRAY_PUSH);
   });
-}, O = (e2, t2, { compileExpression: n }) => {
-  n(e2.expression);
-}, X = (e2, t2, { compileExpression: n }) => {
-  e2.name.text === "length" ? (n(e2.expression), t2.emit(i$2.LENGTH)) : (n(e2.expression), t2.emit(i$2.PUSH, e2.name.text), t2.emit(i$2.PROPERTY_GET));
-}, V$1 = (e2, t2, { compileExpression: n, reportError: r2 }) => {
-  n(e2.expression), e2.argumentExpression ? n(e2.argumentExpression) : r2(e2, "Element access requires an index expression"), t2.emit(i$2.ARRAY_GET);
-}, W$1 = (e2, t2, { compileExpression: n }) => {
+}, O = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.expression);
+}, d$3 = (e2, t2, { compileExpression: i2 }) => {
+  e2.name.text === "length" ? (i2(e2.expression), t2.emit(n.LENGTH)) : (i2(e2.expression), t2.emit(n.PUSH, e2.name.text), t2.emit(n.PROPERTY_GET));
+}, X = (e2, t2, { compileExpression: i2, reportError: r2 }) => {
+  i2(e2.expression), e2.argumentExpression ? i2(e2.argumentExpression) : r2(e2, "Element access requires an index expression"), t2.emit(n.ARRAY_GET);
+}, V$1 = (e2, t2, { compileExpression: i2 }) => {
   switch (e2.operator) {
     case s__namespace.SyntaxKind.ExclamationToken:
-      n(e2.operand), t2.emit(i$2.NOT);
+      i2(e2.operand), t2.emit(n.NOT);
       break;
     case s__namespace.SyntaxKind.MinusToken:
-      n(e2.operand), t2.emit(i$2.UNARY_MINUS);
+      i2(e2.operand), t2.emit(n.UNARY_MINUS);
       break;
     case s__namespace.SyntaxKind.PlusToken:
-      n(e2.operand), t2.emit(i$2.UNARY_PLUS);
+      i2(e2.operand), t2.emit(n.UNARY_PLUS);
       break;
     case s__namespace.SyntaxKind.PlusPlusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.INC, false));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, false));
       break;
     case s__namespace.SyntaxKind.MinusMinusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.DEC, false));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, false));
       break;
   }
-}, d$3 = (e2, t2, { compileExpression: n }) => {
+}, W$1 = (e2, t2, { compileExpression: i2 }) => {
   switch (e2.operator) {
     case s__namespace.SyntaxKind.PlusPlusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.INC, true));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, true));
       break;
     case s__namespace.SyntaxKind.MinusMinusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.DEC, true));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, true));
       break;
   }
-}, j$1 = (e2, t2, { compileExpression: n }) => {
+}, j$1 = (e2, t2, { compileExpression: i2 }) => {
   const r2 = e2.operatorToken.kind;
-  switch (n(e2.left), n(e2.right), r2) {
+  switch (i2(e2.left), i2(e2.right), r2) {
     case s__namespace.SyntaxKind.PlusToken:
-      t2.emit(i$2.ADD);
+      t2.emit(n.ADD);
       break;
     case s__namespace.SyntaxKind.MinusToken:
-      t2.emit(i$2.SUB);
+      t2.emit(n.SUB);
       break;
     case s__namespace.SyntaxKind.AsteriskToken:
-      t2.emit(i$2.MUL);
+      t2.emit(n.MUL);
       break;
     case s__namespace.SyntaxKind.SlashToken:
-      t2.emit(i$2.DIV);
+      t2.emit(n.DIV);
       break;
     case s__namespace.SyntaxKind.PercentToken:
-      t2.emit(i$2.MOD);
+      t2.emit(n.MOD);
       break;
     case s__namespace.SyntaxKind.EqualsEqualsToken:
-      t2.emit(i$2.EQ);
+      t2.emit(n.EQ);
       break;
     case s__namespace.SyntaxKind.ExclamationEqualsToken:
-      t2.emit(i$2.NEQ);
+      t2.emit(n.NEQ);
       break;
     case s__namespace.SyntaxKind.LessThanToken:
-      t2.emit(i$2.LT);
+      t2.emit(n.LT);
       break;
     case s__namespace.SyntaxKind.GreaterThanToken:
-      t2.emit(i$2.GT);
+      t2.emit(n.GT);
       break;
     case s__namespace.SyntaxKind.LessThanEqualsToken:
-      t2.emit(i$2.LTE);
+      t2.emit(n.LTE);
       break;
     case s__namespace.SyntaxKind.GreaterThanEqualsToken:
-      t2.emit(i$2.GTE);
+      t2.emit(n.GTE);
       break;
     case s__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-      t2.emit(i$2.EQ_STRICT);
+      t2.emit(n.EQ_STRICT);
       break;
     case s__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-      t2.emit(i$2.NEQ_STRICT);
+      t2.emit(n.NEQ_STRICT);
       break;
     case s__namespace.SyntaxKind.AmpersandAmpersandToken:
-      t2.emit(i$2.AND);
+      t2.emit(n.AND);
       break;
     case s__namespace.SyntaxKind.BarBarToken:
-      t2.emit(i$2.OR);
+      t2.emit(n.OR);
       break;
   }
-}, v$1 = (e2, t2, { compileExpression: n }) => {
-  n(e2.condition);
-  const r2 = t2.emit(i$2.JUMP_IF_FALSE, -1);
-  n(e2.whenTrue);
-  const a2 = t2.emit(i$2.JUMP, -1), m2 = t2.currentAddress();
-  t2.patchJump(r2, m2), n(e2.whenFalse);
-  const T = t2.currentAddress();
-  t2.patchJump(a2, T);
-}, z = (e2, t2, { compileExpression: n }) => {
-  n(e2.expression), t2.emit(i$2.TYPEOF);
-}, Q$1 = (e2, t2, { compileExpression: n, reportError: r2 }) => {
+}, v$1 = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.condition);
+  const r2 = t2.emit(n.JUMP_IF_FALSE, -1);
+  i2(e2.whenTrue);
+  const a2 = t2.emit(n.JUMP, -1), T = t2.currentAddress();
+  t2.patchJump(r2, T), i2(e2.whenFalse);
+  const S = t2.currentAddress();
+  t2.patchJump(a2, S);
+}, z = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.expression), t2.emit(n.TYPEOF);
+}, Q$1 = (e2, t2, { compileExpression: i2, reportError: r2 }) => {
   if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "fs") {
     const a2 = e2.expression.name.text;
     if (a2 === "listFiles")
-      e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, "."), e2.arguments.length > 1 && n(e2.arguments[1]), t2.emit(i$2.FS_LIST_FILES);
+      e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, "."), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.FS_LIST_FILES);
     else if (a2 === "readFile")
-      e2.arguments.length > 0 ? (n(e2.arguments[0]), t2.emit(i$2.FS_READ_FILE)) : r2(e2, "fs.readFile() requires a path argument");
+      e2.arguments.length > 0 ? (i2(e2.arguments[0]), t2.emit(n.FS_READ_FILE)) : r2(e2, "fs.readFile() requires a path argument");
     else if (a2 === "writeFile") {
       if (e2.arguments.length < 2) {
         r2(e2, "fs.writeFile() requires path and content arguments");
         return;
       }
-      n(e2.arguments[0]), n(e2.arguments[1]), t2.emit(i$2.FS_WRITE_FILE);
+      i2(e2.arguments[0]), i2(e2.arguments[1]), t2.emit(n.FS_WRITE_FILE);
     } else
       r2(e2, `Unsupported fs method: ${a2}`);
   } else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "parse")
-    e2.arguments.length > 0 && n(e2.arguments[0]), t2.emit(i$2.JSON_PARSE);
+    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(n.JSON_PARSE);
   else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "stringify")
-    e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH_UNDEFINED), t2.emit(i$2.JSON_STRINGIFY);
+    e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.JSON_STRINGIFY);
   else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "Object" && e2.expression.name.text === "keys") {
     if (e2.arguments.length !== 1) {
       r2(e2, "Object.keys() requires exactly one argument");
       return;
     }
-    n(e2.arguments[0]), t2.emit(i$2.OBJECT_KEYS);
+    i2(e2.arguments[0]), t2.emit(n.OBJECT_KEYS);
   } else if (s__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
-    e2.arguments.length > 0 && n(e2.arguments[0]), t2.emit(i$2.CC);
+    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(n.CC);
   else if (s__namespace.isPropertyAccessExpression(e2.expression)) {
     const a2 = e2.expression.name.text;
     if (a2 === "substring")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 && n(e2.arguments[1]), t2.emit(i$2.STRING_SUBSTRING);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.STRING_SUBSTRING);
     else if (a2 === "indexOf")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_INDEXOF);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_INDEXOF);
     else if (a2 === "split")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_SPLIT);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_SPLIT);
     else if (a2 === "slice")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH_UNDEFINED), t2.emit(i$2.STRING_SLICE);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.STRING_SLICE);
     else if (a2 === "join")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ","), t2.emit(i$2.ARRAY_JOIN);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ","), t2.emit(n.ARRAY_JOIN);
     else if (a2 === "charAt")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), t2.emit(i$2.STRING_CHARAT);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), t2.emit(n.STRING_CHARAT);
     else if (a2 === "toUpperCase")
-      n(e2.expression.expression), t2.emit(i$2.STRING_TOUPPERCASE);
+      i2(e2.expression.expression), t2.emit(n.STRING_TOUPPERCASE);
     else if (a2 === "toLowerCase")
-      n(e2.expression.expression), t2.emit(i$2.STRING_TOLOWERCASE);
+      i2(e2.expression.expression), t2.emit(n.STRING_TOLOWERCASE);
     else if (a2 === "toString")
-      n(e2.expression.expression), t2.emit(i$2.TO_STRING);
+      i2(e2.expression.expression), t2.emit(n.TO_STRING);
     else if (a2 === "includes")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_INCLUDES);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_INCLUDES);
     else if (a2 === "endsWith")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_ENDS_WITH);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_ENDS_WITH);
     else if (a2 === "startsWith")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_STARTS_WITH);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_STARTS_WITH);
     else if (a2 === "trim")
-      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM);
+      i2(e2.expression.expression), t2.emit(n.STRING_TRIM);
     else if (a2 === "trimStart")
-      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM_START);
+      i2(e2.expression.expression), t2.emit(n.STRING_TRIM_START);
     else if (a2 === "trimEnd")
-      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM_END);
+      i2(e2.expression.expression), t2.emit(n.STRING_TRIM_END);
     else if (a2 === "test")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.REGEX_TEST);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.REGEX_TEST);
     else if (a2 === "match") {
-      if (n(e2.expression.expression), e2.arguments.length > 0)
-        n(e2.arguments[0]);
+      if (i2(e2.expression.expression), e2.arguments.length > 0)
+        i2(e2.arguments[0]);
       else {
         r2(e2, "match() requires a regex argument");
         return;
       }
-      t2.emit(i$2.STRING_MATCH);
+      t2.emit(n.STRING_MATCH);
     } else if (a2 === "replace")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, ""), e2.arguments.length > 0 && s__namespace.isRegularExpressionLiteral(e2.arguments[0]), t2.emit(i$2.STRING_REPLACE_REGEX);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_REPLACE_REGEX);
     else if (a2 === "replaceAll")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_REPLACE_ALL);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_REPLACE_ALL);
     else if (a2 === "lastIndexOf")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_LAST_INDEX_OF);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_LAST_INDEX_OF);
     else if (a2 === "repeat")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), t2.emit(i$2.STRING_REPEAT);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), t2.emit(n.STRING_REPEAT);
     else if (a2 === "padStart")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, " "), t2.emit(i$2.STRING_PAD_START);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, " "), t2.emit(n.STRING_PAD_START);
     else if (a2 === "padEnd")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, " "), t2.emit(i$2.STRING_PAD_END);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, " "), t2.emit(n.STRING_PAD_END);
     else if (a2 === "push")
-      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH_UNDEFINED), t2.emit(i$2.ARRAY_PUSH);
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.ARRAY_PUSH);
     else
       throw new Error(`Method call '${a2}' is not supported`);
   } else
     throw new Error("Unsupported call expression");
-}, $$1 = (e2, t2, { compileExpression: n }) => {
-  t2.emit(i$2.OBJECT_CREATE);
+}, $$1 = (e2, t2, { compileExpression: i2 }) => {
+  t2.emit(n.OBJECT_CREATE);
   for (const r2 of e2.properties)
     if (s__namespace.isPropertyAssignment(r2)) {
       let a2;
@@ -581,93 +583,93 @@ const P = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
         a2 = r2.name.text;
       else
         throw new Error("Computed property names are not supported");
-      t2.emit(i$2.PUSH, a2), n(r2.initializer), t2.emit(i$2.PROPERTY_SET);
+      t2.emit(n.PUSH, a2), i2(r2.initializer), t2.emit(n.PROPERTY_SET);
     } else if (s__namespace.isShorthandPropertyAssignment(r2)) {
       const a2 = r2.name.text;
-      t2.emit(i$2.PUSH, a2), t2.emit(i$2.LOAD, a2), t2.emit(i$2.PROPERTY_SET);
+      t2.emit(n.PUSH, a2), t2.emit(n.LOAD, a2), t2.emit(n.PROPERTY_SET);
     } else
       throw new Error("Unsupported property type in object literal");
 }, Z$1 = {
-  [s__namespace.SyntaxKind.StringLiteral]: H,
-  [s__namespace.SyntaxKind.NumericLiteral]: J,
+  [s__namespace.SyntaxKind.StringLiteral]: J,
+  [s__namespace.SyntaxKind.NumericLiteral]: H,
   [s__namespace.SyntaxKind.TrueKeyword]: M$2,
   [s__namespace.SyntaxKind.FalseKeyword]: Y,
-  [s__namespace.SyntaxKind.NullKeyword]: C$2,
-  [s__namespace.SyntaxKind.RegularExpressionLiteral]: B$1,
+  [s__namespace.SyntaxKind.NullKeyword]: B$1,
+  [s__namespace.SyntaxKind.RegularExpressionLiteral]: C$2,
   [s__namespace.SyntaxKind.Identifier]: w$1,
   [s__namespace.SyntaxKind.ArrayLiteralExpression]: q,
   [s__namespace.SyntaxKind.BinaryExpression]: j$1,
-  [s__namespace.SyntaxKind.PrefixUnaryExpression]: W$1,
-  [s__namespace.SyntaxKind.PostfixUnaryExpression]: d$3,
+  [s__namespace.SyntaxKind.PrefixUnaryExpression]: V$1,
+  [s__namespace.SyntaxKind.PostfixUnaryExpression]: W$1,
   [s__namespace.SyntaxKind.CallExpression]: Q$1,
-  [s__namespace.SyntaxKind.PropertyAccessExpression]: X,
-  [s__namespace.SyntaxKind.ElementAccessExpression]: V$1,
+  [s__namespace.SyntaxKind.PropertyAccessExpression]: d$3,
+  [s__namespace.SyntaxKind.ElementAccessExpression]: X,
   [s__namespace.SyntaxKind.ConditionalExpression]: v$1,
   [s__namespace.SyntaxKind.TypeOfExpression]: z,
   [s__namespace.SyntaxKind.ParenthesizedExpression]: O,
   [s__namespace.SyntaxKind.ObjectLiteralExpression]: $$1
 };
 function te$1(e2) {
-  const t2 = [], n = A$1(e2);
-  if (n.errors.length > 0)
+  const t2 = [], i2 = A$1(e2);
+  if (i2.errors.length > 0)
     return {
       success: false,
       bytecode: [],
-      errors: n.errors.map((S) => ({
-        message: S,
+      errors: i2.errors.map((m2) => ({
+        message: m2,
         line: 0,
         character: 0
       }))
     };
-  const r2 = new g(), a2 = s__namespace.createSourceFile("program.ts", e2, s__namespace.ScriptTarget.Latest, true), m2 = {
-    compileStatement: T,
-    compileExpression: l,
-    reportError: (S, u2) => {
-      const { line: c2, character: R } = a2.getLineAndCharacterOfPosition(S.getStart());
+  const r2 = new g(), a2 = s__namespace.createSourceFile("program.ts", e2, s__namespace.ScriptTarget.Latest, true), T = {
+    compileStatement: S,
+    compileExpression: c2,
+    reportError: (m2, u2) => {
+      const { line: l, character: R } = a2.getLineAndCharacterOfPosition(m2.getStart());
       throw t2.push({
         message: u2,
-        line: c2 + 1,
+        line: l + 1,
         // TypeScript uses 0-based lines
         character: R + 1
         // TypeScript uses 0-based columns
       }), new Error(u2);
     }
   };
-  function T(S) {
-    const u2 = K[S.kind];
+  function S(m2) {
+    const u2 = K[m2.kind];
     if (u2)
-      u2(S, r2, m2);
+      u2(m2, r2, T);
     else {
-      const { line: c2, character: R } = a2.getLineAndCharacterOfPosition(S.getStart());
+      const { line: l, character: R } = a2.getLineAndCharacterOfPosition(m2.getStart());
       t2.push({
-        message: `Unsupported statement: ${s__namespace.SyntaxKind[S.kind]}`,
-        line: c2 + 1,
+        message: `Unsupported statement: ${s__namespace.SyntaxKind[m2.kind]}`,
+        line: l + 1,
         character: R + 1
       });
     }
   }
-  function l(S) {
-    const u2 = Z$1[S.kind];
+  function c2(m2) {
+    const u2 = Z$1[m2.kind];
     if (u2)
-      u2(S, r2, m2);
+      u2(m2, r2, T);
     else {
-      const { line: c2, character: R } = a2.getLineAndCharacterOfPosition(S.getStart());
+      const { line: l, character: R } = a2.getLineAndCharacterOfPosition(m2.getStart());
       t2.push({
-        message: `Unsupported expression: ${s__namespace.SyntaxKind[S.kind]}`,
-        line: c2 + 1,
+        message: `Unsupported expression: ${s__namespace.SyntaxKind[m2.kind]}`,
+        line: l + 1,
         character: R + 1
       });
     }
   }
-  return a2.forEachChild((S) => {
+  return a2.forEachChild((m2) => {
     var u2;
-    s__namespace.isFunctionDeclaration(S) && ((u2 = S.name) == null ? void 0 : u2.text) === "main" && S.body && S.body.statements.forEach((c2) => {
+    s__namespace.isFunctionDeclaration(m2) && ((u2 = m2.name) == null ? void 0 : u2.text) === "main" && m2.body && m2.body.statements.forEach((l) => {
       try {
-        T(c2);
+        S(l);
       } catch {
       }
     });
-  }), r2.emit(i$2.HALT), {
+  }), r2.emit(n.HALT), {
     success: t2.length === 0,
     bytecode: r2.getBytecode(),
     errors: t2
@@ -715,13 +717,13 @@ function m(r2) {
   if (f$2(r2)) return 0;
   if (c(r2)) return NaN;
   if (t(r2)) {
-    const n = r2.trim();
-    return n === "" ? 0 : Number(n);
+    const n2 = r2.trim();
+    return n2 === "" ? 0 : Number(n2);
   }
   return o(r2) ? NaN : Number(r2);
 }
-function s(r2 = [], n) {
-  return n ? { type: "array", elements: r2, properties: n } : { type: "array", elements: r2 };
+function s(r2 = [], n2) {
+  return n2 ? { type: "array", elements: r2, properties: n2 } : { type: "array", elements: r2 };
 }
 function C$1() {
   return { type: "undefined" };
@@ -730,8 +732,8 @@ function M$1(r2 = {}) {
   return { type: "object", properties: r2 };
 }
 var d$1 = Object.defineProperty;
-var h = (s2, t2, n) => t2 in s2 ? d$1(s2, t2, { enumerable: true, configurable: true, writable: true, value: n }) : s2[t2] = n;
-var a = (s2, t2, n) => h(s2, typeof t2 != "symbol" ? t2 + "" : t2, n);
+var h = (s2, t2, n2) => t2 in s2 ? d$1(s2, t2, { enumerable: true, configurable: true, writable: true, value: n2 }) : s2[t2] = n2;
+var a = (s2, t2, n2) => h(s2, typeof t2 != "symbol" ? t2 + "" : t2, n2);
 class p {
   constructor(t2) {
     a(this, "connected", false);
@@ -754,14 +756,14 @@ class p {
   }
   async saveProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = r__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
-    await b$2.promises.writeFile(n, e2, "utf-8");
+    const n2 = r__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await b$2.promises.writeFile(n2, e2, "utf-8");
   }
   async getProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = r__namespace.join(this.programsDir, `${t2}.json`);
+    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      const e2 = await b$2.promises.readFile(n, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await b$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -771,14 +773,14 @@ class p {
   }
   async saveExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = r__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
-    await b$2.promises.writeFile(n, e2, "utf-8");
+    const n2 = r__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await b$2.promises.writeFile(n2, e2, "utf-8");
   }
   async getExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = r__namespace.join(this.executionsDir, `${t2}.json`);
+    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      const e2 = await b$2.promises.readFile(n, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await b$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -786,18 +788,18 @@ class p {
       throw e2;
     }
   }
-  async appendOutput(t2, n) {
+  async appendOutput(t2, n2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`), o2 = n.join(`
+    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
 `) + `
 `;
     await b$2.promises.appendFile(e2, o2, "utf-8");
   }
   async getOutput(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = r__namespace.join(this.outputsDir, `${t2}.output`);
+    const n2 = r__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      return (await b$2.promises.readFile(n, "utf-8")).split(`
+      return (await b$2.promises.readFile(n2, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -807,13 +809,13 @@ class p {
   }
   async listExecutions() {
     if (!this.connected) throw new Error("Not connected");
-    const t2 = await b$2.promises.readdir(this.executionsDir), n = [];
+    const t2 = await b$2.promises.readdir(this.executionsDir), n2 = [];
     for (const e2 of t2)
       if (e2.endsWith(".json")) {
         const o2 = e2.slice(0, -5), i2 = await this.getExecution(o2);
-        i2 && n.push(i2);
+        i2 && n2.push(i2);
       }
-    return n;
+    return n2;
   }
   async getCurrentExecutionId() {
     if (!this.connected) throw new Error("Not connected");
@@ -828,14 +830,14 @@ class p {
   }
   async setCurrentExecutionId(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = { currentExecutionId: t2 };
-    await b$2.promises.writeFile(this.metadataFile, JSON.stringify(n, null, 2), "utf-8");
+    const n2 = { currentExecutionId: t2 };
+    await b$2.promises.writeFile(this.metadataFile, JSON.stringify(n2, null, 2), "utf-8");
   }
   async deleteExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = r__namespace.join(this.executionsDir, `${t2}.json`);
+    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      await b$2.promises.unlink(n);
+      await b$2.promises.unlink(n2);
     } catch (i2) {
       if (i2.code !== "ENOENT") throw i2;
     }
@@ -849,19 +851,19 @@ class p {
   }
   async listPrograms() {
     if (!this.connected) throw new Error("Not connected");
-    const t2 = await b$2.promises.readdir(this.programsDir), n = [];
+    const t2 = await b$2.promises.readdir(this.programsDir), n2 = [];
     for (const e2 of t2)
       if (e2.endsWith(".json")) {
         const o2 = e2.slice(0, -5), i2 = await this.getProgram(o2);
-        i2 && n.push(i2);
+        i2 && n2.push(i2);
       }
-    return n;
+    return n2;
   }
   async deleteProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n = r__namespace.join(this.programsDir, `${t2}.json`);
+    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      await b$2.promises.unlink(n);
+      await b$2.promises.unlink(n2);
     } catch (e2) {
       if (e2.code !== "ENOENT") throw e2;
     }
@@ -890,7 +892,7 @@ let f$1 = class f {
   }
   async getCollections() {
     if (!this.db) throw new Error("Not connected to database");
-    return (await this.db.listCollections().toArray()).map((n) => n.name);
+    return (await this.db.listCollections().toArray()).map((n2) => n2.name);
   }
   getCollection(t2) {
     if (!this.db) throw new Error("Not connected to database");
@@ -916,12 +918,12 @@ let f$1 = class f {
   async getExecution(t2) {
     return await this.getCollection("executions").findOne({ id: t2 });
   }
-  async appendOutput(t2, n) {
+  async appendOutput(t2, n2) {
     const e2 = this.getCollection("outputs");
     await e2.findOne({ executionId: t2 }) ? await e2.updateOne(
       { executionId: t2 },
-      { $push: { lines: { $each: n } } }
-    ) : await e2.insertOne({ executionId: t2, lines: n });
+      { $push: { lines: { $each: n2 } } }
+    ) : await e2.insertOne({ executionId: t2, lines: n2 });
   }
   async getOutput(t2) {
     const e2 = await this.getCollection("outputs").findOne({ executionId: t2 });
@@ -931,8 +933,8 @@ let f$1 = class f {
     return await this.getCollection("executions").find({}).toArray();
   }
   async getCurrentExecutionId() {
-    const n = await this.getCollection("metadata").findOne({ _id: "current" });
-    return (n == null ? void 0 : n.currentExecutionId) || null;
+    const n2 = await this.getCollection("metadata").findOne({ _id: "current" });
+    return (n2 == null ? void 0 : n2.currentExecutionId) || null;
   }
   async setCurrentExecutionId(t2) {
     await this.getCollection("metadata").replaceOne(
@@ -943,7 +945,7 @@ let f$1 = class f {
   }
   async deleteExecution(t2) {
     var o2;
-    let n = true;
+    let n2 = true;
     const e2 = this.client.startSession();
     try {
       await e2.withTransaction(async () => {
@@ -955,13 +957,13 @@ let f$1 = class f {
       });
     } catch (i2) {
       if ((o2 = i2 == null ? void 0 : i2.message) != null && o2.includes("Transaction numbers are only allowed"))
-        n = false;
+        n2 = false;
       else
         throw i2;
     } finally {
       await e2.endSession();
     }
-    n || (await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null));
+    n2 || (await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null));
   }
   async listPrograms() {
     return await this.getCollection("programs").find({}).toArray();
@@ -972,8 +974,8 @@ let f$1 = class f {
 };
 class E {
   static create(t2) {
-    const n = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
-    switch (n) {
+    const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
+    switch (n2) {
       case "file": {
         const e2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
         return new p(e2);
@@ -983,7 +985,7 @@ class E {
         return new f$1(e2);
       }
       default:
-        throw new Error(`Unsupported storage type: ${n}`);
+        throw new Error(`Unsupported storage type: ${n2}`);
     }
   }
 }
@@ -998,11 +1000,11 @@ function d(e2, t2) {
     type: "RuntimeError",
     message: "Stack underflow",
     pc: e2.pc,
-    opcode: t2 || i$2.POP
+    opcode: t2 || n.POP
   } : e2.stack.pop();
 }
 const f2 = Q, Z = {
-  [i$2.ADD]: {
+  [n.ADD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -1018,7 +1020,7 @@ const f2 = Q, Z = {
       }
     }
   },
-  [i$2.SUB]: {
+  [n.SUB]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1030,7 +1032,7 @@ const f2 = Q, Z = {
       e2.stack.push(s2 - c2);
     }
   },
-  [i$2.MUL]: {
+  [n.MUL]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1042,7 +1044,7 @@ const f2 = Q, Z = {
       e2.stack.push(s2 * c2);
     }
   },
-  [i$2.DIV]: {
+  [n.DIV]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1061,7 +1063,7 @@ const f2 = Q, Z = {
       e2.stack.push(s2 / c2);
     }
   },
-  [i$2.MOD]: {
+  [n.MOD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1073,7 +1075,7 @@ const f2 = Q, Z = {
       e2.stack.push(s2 % c2);
     }
   },
-  [i$2.UNARY_MINUS]: {
+  [n.UNARY_MINUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1083,7 +1085,7 @@ const f2 = Q, Z = {
       e2.stack.push(-o2);
     }
   },
-  [i$2.UNARY_PLUS]: {
+  [n.UNARY_PLUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1094,28 +1096,28 @@ const f2 = Q, Z = {
     }
   }
 }, ee = {
-  [i$2.PUSH]: {
+  [n.PUSH]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
       e2.stack.push(t2.arg);
     }
   },
-  [i$2.PUSH_UNDEFINED]: {
+  [n.PUSH_UNDEFINED]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
       e2.stack.push(C$1());
     }
   },
-  [i$2.POP]: {
+  [n.POP]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
       e2.stack.pop();
     }
   },
-  [i$2.DUP]: {
+  [n.DUP]: {
     stackIn: 1,
     stackOut: 2,
     execute: (e2, t2) => {
@@ -1123,7 +1125,7 @@ const f2 = Q, Z = {
       e2.stack.push(r2), e2.stack.push(r2);
     }
   },
-  [i$2.SWAP]: {
+  [n.SWAP]: {
     stackIn: 2,
     stackOut: 2,
     execute: (e2, t2) => {
@@ -1131,7 +1133,7 @@ const f2 = Q, Z = {
       e2.stack.push(r2), e2.stack.push(o2);
     }
   },
-  [i$2.DUP2]: {
+  [n.DUP2]: {
     stackIn: 2,
     stackOut: 4,
     execute: (e2, t2) => {
@@ -1140,7 +1142,7 @@ const f2 = Q, Z = {
     }
   }
 }, re = {
-  [i$2.PRINT]: {
+  [n.PRINT]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
@@ -1148,7 +1150,7 @@ const f2 = Q, Z = {
       t2 !== void 0 && e2.output.push(p$1(t2));
     }
   },
-  [i$2.CC]: {
+  [n.CC]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1159,7 +1161,7 @@ const f2 = Q, Z = {
     }
   }
 }, te = {
-  [i$2.HALT]: {
+  [n.HALT]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1167,7 +1169,7 @@ const f2 = Q, Z = {
       e2.status = "complete";
     }
   },
-  [i$2.JUMP]: {
+  [n.JUMP]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1190,7 +1192,7 @@ const f2 = Q, Z = {
       e2.pc = r2;
     }
   },
-  [i$2.JUMP_IF_FALSE]: {
+  [n.JUMP_IF_FALSE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1214,7 +1216,7 @@ const f2 = Q, Z = {
       j(r2) ? e2.pc++ : e2.pc = o2;
     }
   },
-  [i$2.JUMP_IF]: {
+  [n.JUMP_IF]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1238,7 +1240,7 @@ const f2 = Q, Z = {
       j(r2) ? e2.pc = o2 : e2.pc++;
     }
   },
-  [i$2.JUMP_IF_TRUE]: {
+  [n.JUMP_IF_TRUE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1262,7 +1264,7 @@ const f2 = Q, Z = {
       j(r2) ? e2.pc = o2 : e2.pc++;
     }
   },
-  [i$2.CALL]: {
+  [n.CALL]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: false,
@@ -1270,11 +1272,11 @@ const f2 = Q, Z = {
       type: "RuntimeError",
       message: "Functions not implemented",
       pc: e2.pc,
-      opcode: i$2.CALL
+      opcode: n.CALL
     })
   }
 }, oe = {
-  [i$2.LOAD]: {
+  [n.LOAD]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1282,7 +1284,7 @@ const f2 = Q, Z = {
       e2.variables.has(r2) ? e2.stack.push(e2.variables.get(r2)) : e2.stack.push(C$1());
     }
   },
-  [i$2.STORE]: {
+  [n.STORE]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1291,7 +1293,7 @@ const f2 = Q, Z = {
     }
   }
 }, se = {
-  [i$2.ITER_START]: {
+  [n.ITER_START]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1303,7 +1305,7 @@ const f2 = Q, Z = {
           pc: e2.pc,
           opcode: t2.op
         };
-      let o$12;
+      let o$1;
       if (u$1(r2)) {
         const s2 = e2.heap.get(r2.id);
         if (!s2 || s2.type !== "array")
@@ -1313,9 +1315,9 @@ const f2 = Q, Z = {
             pc: e2.pc,
             opcode: t2.op
           };
-        o$12 = s2.data;
+        o$1 = s2.data;
       } else if (o(r2))
-        o$12 = r2;
+        o$1 = r2;
       else
         return {
           type: "TypeError",
@@ -1331,13 +1333,13 @@ const f2 = Q, Z = {
           opcode: t2.op
         };
       e2.iterators.push({
-        array: o$12,
+        array: o$1,
         index: 0,
-        length: o$12.elements.length
+        length: o$1.elements.length
       });
     }
   },
-  [i$2.ITER_NEXT]: {
+  [n.ITER_NEXT]: {
     stackIn: 0,
     stackOut: 2,
     // Pushes element and hasMore flag
@@ -1353,7 +1355,7 @@ const f2 = Q, Z = {
       r2.index < r2.length ? (r2.array && r2.index < r2.array.elements.length ? e2.stack.push(r2.array.elements[r2.index]) : e2.stack.push(C$1()), e2.stack.push(true), r2.index++) : (e2.stack.push(null), e2.stack.push(false));
     }
   },
-  [i$2.ITER_END]: {
+  [n.ITER_END]: {
     stackIn: 0,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1377,7 +1379,7 @@ function v(e2, t2, r2) {
   e2.stack.push(c2);
 }
 const ce = {
-  [i$2.EQ]: {
+  [n.EQ]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => {
@@ -1393,7 +1395,7 @@ const ce = {
       }
     })
   },
-  [i$2.NEQ]: {
+  [n.NEQ]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => {
@@ -1409,7 +1411,7 @@ const ce = {
       }
     })
   },
-  [i$2.LT]: {
+  [n.LT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => {
@@ -1417,7 +1419,7 @@ const ce = {
       return s2 < c2;
     })
   },
-  [i$2.GT]: {
+  [n.GT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => {
@@ -1425,7 +1427,7 @@ const ce = {
       return s2 > c2;
     })
   },
-  [i$2.LTE]: {
+  [n.LTE]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => {
@@ -1433,7 +1435,7 @@ const ce = {
       return s2 <= c2;
     })
   },
-  [i$2.GTE]: {
+  [n.GTE]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => {
@@ -1441,18 +1443,18 @@ const ce = {
       return s2 >= c2;
     })
   },
-  [i$2.EQ_STRICT]: {
+  [n.EQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id === o2.id : r2 === o2)
   },
-  [i$2.NEQ_STRICT]: {
+  [n.NEQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => v(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id !== o2.id : r2 !== o2)
   }
 }, ne = {
-  [i$2.AND]: {
+  [n.AND]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1464,7 +1466,7 @@ const ce = {
       e2.stack.push(s2);
     }
   },
-  [i$2.OR]: {
+  [n.OR]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1476,7 +1478,7 @@ const ce = {
       e2.stack.push(s2);
     }
   },
-  [i$2.NOT]: {
+  [n.NOT]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1491,7 +1493,7 @@ const ce = {
    * ARRAY_NEW: Creates a new empty array on the heap
    * Stack: [] -> [array-ref]
    */
-  [i$2.ARRAY_NEW]: {
+  [n.ARRAY_NEW]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1503,14 +1505,14 @@ const ce = {
    * ARRAY_PUSH: Pushes a value to the end of an array
    * Stack: [array-ref, value] -> [array-ref]
    */
-  [i$2.ARRAY_PUSH]: {
+  [n.ARRAY_PUSH]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o$12 = e2.stack.pop();
+      const r2 = e2.stack.pop(), o$1 = e2.stack.pop();
       let s2;
-      if (u$1(o$12)) {
-        const c2 = e2.heap.get(o$12.id);
+      if (u$1(o$1)) {
+        const c2 = e2.heap.get(o$1.id);
         if (!c2 || c2.type !== "array")
           return {
             type: "RuntimeError",
@@ -1519,8 +1521,8 @@ const ce = {
             opcode: t2.op
           };
         s2 = c2.data;
-      } else if (o(o$12))
-        s2 = o$12;
+      } else if (o(o$1))
+        s2 = o$1;
       else
         return {
           type: "RuntimeError",
@@ -1528,49 +1530,49 @@ const ce = {
           pc: e2.pc,
           opcode: t2.op
         };
-      s2.elements.push(r2), e2.stack.push(o$12);
+      s2.elements.push(r2), e2.stack.push(o$1);
     }
   },
-  [i$2.ARRAY_GET]: {
+  [n.ARRAY_GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
       var a2;
-      const r2 = e2.stack.pop(), o$12 = e2.stack.pop();
+      const r2 = e2.stack.pop(), o$1 = e2.stack.pop();
       let s2;
-      if (u$1(o$12)) {
-        const u2 = e2.heap.get(o$12.id);
-        if (!u2 || u2.type !== "array")
+      if (u$1(o$1)) {
+        const i2 = e2.heap.get(o$1.id);
+        if (!i2 || i2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        s2 = u2.data;
-      } else if (b(o$12)) {
-        const u2 = e2.heap.get(o$12.id);
-        if (!u2 || u2.type !== "object")
+        s2 = i2.data;
+      } else if (b(o$1)) {
+        const i2 = e2.heap.get(o$1.id);
+        if (!i2 || i2.type !== "object")
           return {
             type: "RuntimeError",
             message: "Invalid object reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        const i2 = u2.data, y2 = p$1(r2), E2 = i2.properties[y2] ?? C$1();
+        const u2 = i2.data, y2 = p$1(r2), E2 = u2.properties[y2] ?? C$1();
         e2.stack.push(E2);
         return;
-      } else if (o(o$12))
-        s2 = o$12;
-      else if (t(o$12)) {
-        let u2;
+      } else if (o(o$1))
+        s2 = o$1;
+      else if (t(o$1)) {
+        let i2;
         if (i$1(r2))
-          u2 = r2;
+          i2 = r2;
         else if (t(r2)) {
-          const i2 = parseInt(r2, 10);
-          !isNaN(i2) && i2.toString() === r2 && (u2 = i2);
+          const u2 = parseInt(r2, 10);
+          !isNaN(u2) && u2.toString() === r2 && (i2 = u2);
         }
-        u2 !== void 0 && u2 >= 0 && u2 < o$12.length ? e2.stack.push(o$12[u2]) : e2.stack.push(C$1());
+        i2 !== void 0 && i2 >= 0 && i2 < o$1.length ? e2.stack.push(o$1[i2]) : e2.stack.push(C$1());
         return;
       } else
         return {
@@ -1583,12 +1585,12 @@ const ce = {
       if (i$1(r2))
         c2 = r2;
       else if (t(r2)) {
-        const u2 = parseInt(r2, 10);
-        if (!isNaN(u2) && u2.toString() === r2 && u2 >= 0)
-          c2 = u2;
+        const i2 = parseInt(r2, 10);
+        if (!isNaN(i2) && i2.toString() === r2 && i2 >= 0)
+          c2 = i2;
         else {
-          const i2 = ((a2 = s2.properties) == null ? void 0 : a2[r2]) ?? C$1();
-          e2.stack.push(i2);
+          const u2 = ((a2 = s2.properties) == null ? void 0 : a2[r2]) ?? C$1();
+          e2.stack.push(u2);
           return;
         }
       } else
@@ -1602,33 +1604,33 @@ const ce = {
       e2.stack.push(p2);
     }
   },
-  [i$2.ARRAY_SET]: {
+  [n.ARRAY_SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o$12 = e2.stack.pop(), s2 = e2.stack.pop();
+      const r2 = e2.stack.pop(), o$1 = e2.stack.pop(), s2 = e2.stack.pop();
       let c2;
       if (u$1(s2)) {
-        const u2 = e2.heap.get(s2.id);
-        if (!u2 || u2.type !== "array")
+        const i2 = e2.heap.get(s2.id);
+        if (!i2 || i2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        c2 = u2.data;
+        c2 = i2.data;
       } else if (b(s2)) {
-        const u2 = e2.heap.get(s2.id);
-        if (!u2 || u2.type !== "object")
+        const i2 = e2.heap.get(s2.id);
+        if (!i2 || i2.type !== "object")
           return {
             type: "RuntimeError",
             message: "Invalid object reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        const i2 = u2.data, y2 = p$1(o$12);
-        i2.properties[y2] = r2, e2.stack.push(s2);
+        const u2 = i2.data, y2 = p$1(o$1);
+        u2.properties[y2] = r2, e2.stack.push(s2);
         return;
       } else if (o(s2))
         c2 = s2;
@@ -1640,14 +1642,14 @@ const ce = {
           opcode: t$1.op
         };
       let p2;
-      if (i$1(o$12))
-        p2 = o$12;
-      else if (t(o$12)) {
-        const u2 = parseInt(o$12, 10);
-        if (!isNaN(u2) && u2.toString() === o$12 && u2 >= 0)
-          p2 = u2;
+      if (i$1(o$1))
+        p2 = o$1;
+      else if (t(o$1)) {
+        const i2 = parseInt(o$1, 10);
+        if (!isNaN(i2) && i2.toString() === o$1 && i2 >= 0)
+          p2 = i2;
         else {
-          c2.properties || (c2.properties = {}), c2.properties[o$12] = r2, e2.stack.push(s2);
+          c2.properties || (c2.properties = {}), c2.properties[o$1] = r2, e2.stack.push(s2);
           return;
         }
       } else
@@ -1668,12 +1670,12 @@ const ce = {
       c2.elements[a2] = r2, e2.stack.push(s2);
     }
   },
-  [i$2.ARRAY_LEN]: {
+  [n.ARRAY_LEN]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
       const r2 = e2.stack.pop();
-      let o$12;
+      let o$1;
       if (u$1(r2)) {
         const s2 = e2.heap.get(r2.id);
         if (!s2 || s2.type !== "array")
@@ -1683,9 +1685,9 @@ const ce = {
             pc: e2.pc,
             opcode: t2.op
           };
-        o$12 = s2.data;
+        o$1 = s2.data;
       } else if (o(r2))
-        o$12 = r2;
+        o$1 = r2;
       else
         return {
           type: "RuntimeError",
@@ -1693,10 +1695,10 @@ const ce = {
           pc: e2.pc,
           opcode: t2.op
         };
-      e2.stack.push(o$12.elements.length);
+      e2.stack.push(o$1.elements.length);
     }
   },
-  [i$2.ARRAY_MAP_PROP]: {
+  [n.ARRAY_MAP_PROP]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1717,11 +1719,11 @@ const ce = {
           opcode: t2.op
         };
       const c2 = s$12.data, p2 = s();
-      for (const u2 of c2.elements)
-        if (b(u2)) {
-          const i2 = e2.heap.get(u2.id);
-          if (i2 && i2.type === "object") {
-            const y2 = i2.data, E2 = p$1(r2);
+      for (const i2 of c2.elements)
+        if (b(i2)) {
+          const u2 = e2.heap.get(i2.id);
+          if (u2 && u2.type === "object") {
+            const y2 = u2.data, E2 = p$1(r2);
             p2.elements.push(y2.properties[E2] || null);
           } else
             p2.elements.push(null);
@@ -1731,7 +1733,7 @@ const ce = {
       e2.stack.push(a2);
     }
   },
-  [i$2.ARRAY_FILTER_PROP]: {
+  [n.ARRAY_FILTER_PROP]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1752,19 +1754,19 @@ const ce = {
           opcode: t2.op
         };
       const c2 = s$12.data, p2 = s();
-      for (const u2 of c2.elements)
-        if (b(u2)) {
-          const i2 = e2.heap.get(u2.id);
-          if (i2 && i2.type === "object") {
-            const y2 = i2.data, E2 = p$1(r2);
-            E2 in y2.properties && y2.properties[E2] && p2.elements.push(u2);
+      for (const i2 of c2.elements)
+        if (b(i2)) {
+          const u2 = e2.heap.get(i2.id);
+          if (u2 && u2.type === "object") {
+            const y2 = u2.data, E2 = p$1(r2);
+            E2 in y2.properties && y2.properties[E2] && p2.elements.push(i2);
           }
         }
       const a2 = e2.heap.allocate("array", p2);
       e2.stack.push(a2);
     }
   },
-  [i$2.ARRAY_SLICE]: {
+  [n.ARRAY_SLICE]: {
     stackIn: 3,
     // array, start, end
     stackOut: 1,
@@ -1782,11 +1784,11 @@ const ce = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const a2 = e2.heap.get(s$12.id).data, u2 = i$1(o2) ? o2 : 0, i2 = r2 === void 0 ? a2.elements.length : i$1(r2) ? r2 : a2.elements.length, y2 = u2 < 0 ? Math.max(0, a2.elements.length + u2) : u2, E2 = i2 < 0 ? Math.max(0, a2.elements.length + i2) : i2, J2 = a2.elements.slice(y2, E2), Y2 = s(J2), z2 = e2.heap.allocate("array", Y2);
+      const a2 = e2.heap.get(s$12.id).data, i2 = i$1(o2) ? o2 : 0, u2 = r2 === void 0 ? a2.elements.length : i$1(r2) ? r2 : a2.elements.length, y2 = i2 < 0 ? Math.max(0, a2.elements.length + i2) : i2, E2 = u2 < 0 ? Math.max(0, a2.elements.length + u2) : u2, J2 = a2.elements.slice(y2, E2), Y2 = s(J2), z2 = e2.heap.allocate("array", Y2);
       e2.stack.push(z2);
     }
   },
-  [i$2.ARRAY_JOIN]: {
+  [n.ARRAY_JOIN]: {
     stackIn: 2,
     // array, separator
     stackOut: 1,
@@ -1805,11 +1807,11 @@ const ce = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const p2 = e2.heap.get(o2.id).data, a2 = t(r2) ? r2 : String(r2), i2 = p2.elements.map((y2) => y2 === null ? "null" : y2 === void 0 || c(y2) ? "undefined" : String(y2)).join(a2);
-      e2.stack.push(i2);
+      const p2 = e2.heap.get(o2.id).data, a2 = t(r2) ? r2 : String(r2), u2 = p2.elements.map((y2) => y2 === null ? "null" : y2 === void 0 || c(y2) ? "undefined" : String(y2)).join(a2);
+      e2.stack.push(u2);
     }
   },
-  [i$2.ARRAY_INDEX_OF]: {
+  [n.ARRAY_INDEX_OF]: {
     stackIn: 2,
     // array, searchElement
     stackOut: 1,
@@ -1819,8 +1821,8 @@ const ce = {
       if (!((a2) => {
         if (!u$1(a2))
           return false;
-        const u2 = e2.heap.get(a2.id);
-        return u2 !== void 0 && u2.type === "array";
+        const i2 = e2.heap.get(a2.id);
+        return i2 !== void 0 && i2.type === "array";
       })(o2))
         return {
           type: "RuntimeError",
@@ -1859,7 +1861,7 @@ function M(e2, t2) {
   }
 }
 const ae = {
-  [i$2.CONCAT]: {
+  [n.CONCAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1870,7 +1872,7 @@ const ae = {
       e2.stack.push(p$1(o2) + p$1(r2));
     }
   },
-  [i$2.STRING_LEN]: {
+  [n.STRING_LEN]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -1886,7 +1888,7 @@ const ae = {
       e2.stack.push(r2.length);
     }
   },
-  [i$2.LENGTH]: {
+  [n.LENGTH]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -1916,7 +1918,7 @@ const ae = {
         };
     }
   },
-  [i$2.JSON_PARSE]: {
+  [n.JSON_PARSE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -1937,7 +1939,7 @@ const ae = {
       }
     }
   },
-  [i$2.TYPEOF]: {
+  [n.TYPEOF]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1946,8 +1948,8 @@ const ae = {
       e2.stack.push(d$2(r2));
     }
   }
-}, ue = {
-  [i$2.INC]: {
+}, ie = {
+  [n.INC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1965,7 +1967,7 @@ const ae = {
       e2.stack.push(c2 ? m(o2) : s2);
     }
   },
-  [i$2.DEC]: {
+  [n.DEC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1983,8 +1985,8 @@ const ae = {
       e2.stack.push(c2 ? m(o2) : s2);
     }
   }
-}, ie = {
-  [i$2.RETURN]: {
+}, ue = {
+  [n.RETURN]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1993,7 +1995,7 @@ const ae = {
       e2.returnValue = r2, e2.status = "complete";
     }
   },
-  [i$2.BREAK]: {
+  [n.BREAK]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -2016,7 +2018,7 @@ const ae = {
       e2.pc = r2;
     }
   },
-  [i$2.CONTINUE]: {
+  [n.CONTINUE]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -2029,17 +2031,17 @@ const ae = {
           opcode: t2.op
         };
       const r2 = t2.arg;
-      if (r2 < 0)
+      if (r2 < 0 || r2 === -1)
         return {
           type: "RuntimeError",
-          message: `Invalid continue target: ${r2}`,
+          message: `Invalid continue target: ${r2} (not patched properly during compilation)`,
           pc: e2.pc,
           opcode: t2.op
         };
       e2.pc = r2;
     }
   },
-  [i$2.FS_LIST_FILES]: {
+  [n.FS_LIST_FILES]: {
     stackIn: 1,
     // Minimum 1 argument (path), optionally 2 (path + options)
     stackOut: 1,
@@ -2051,9 +2053,9 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      let r2, o$12 = {};
+      let r2, o$1 = {};
       const s2 = e2.stack[e2.stack.length - 1];
-      if (e2.stack.length >= 2 && typeof s2 == "object" && s2 !== null && !o(s2) && (o$12 = e2.stack.pop()), r2 = e2.stack.pop(), !t(r2))
+      if (e2.stack.length >= 2 && typeof s2 == "object" && s2 !== null && !o(s2) && (o$1 = e2.stack.pop()), r2 = e2.stack.pop(), !t(r2))
         return {
           type: "RuntimeError",
           message: "FS_LIST_FILES requires a string path",
@@ -2067,7 +2069,7 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const c2 = e2.fileSystem.listFiles(r2, o$12);
+      const c2 = e2.fileSystem.listFiles(r2, o$1);
       if (o(c2)) {
         const p2 = e2.heap.allocate("array", c2);
         e2.stack.push(p2);
@@ -2075,7 +2077,7 @@ const ae = {
         e2.stack.push(c2);
     }
   },
-  [i$2.FS_READ_FILE]: {
+  [n.FS_READ_FILE]: {
     stackIn: 1,
     // path
     stackOut: 1,
@@ -2100,7 +2102,7 @@ const ae = {
       e2.stack.push(o2);
     }
   },
-  [i$2.FS_WRITE_FILE]: {
+  [n.FS_WRITE_FILE]: {
     stackIn: 2,
     // path, content
     stackOut: 1,
@@ -2133,7 +2135,7 @@ const ae = {
     }
   },
   // String method handlers
-  [i$2.STRING_SUBSTRING]: {
+  [n.STRING_SUBSTRING]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -2162,13 +2164,13 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const u2 = o2.length;
-      s2 < 0 && (s2 = Math.max(0, u2 + s2)), c2 !== void 0 && c2 < 0 && (c2 = Math.max(0, u2 + c2));
-      const i2 = c2 !== void 0 ? o2.substring(s2, c2) : o2.substring(s2);
-      e2.stack.push(i2);
+      const i2 = o2.length;
+      s2 < 0 && (s2 = Math.max(0, i2 + s2)), c2 !== void 0 && c2 < 0 && (c2 = Math.max(0, i2 + c2));
+      const u2 = c2 !== void 0 ? o2.substring(s2, c2) : o2.substring(s2);
+      e2.stack.push(u2);
     }
   },
-  [i$2.STRING_INDEXOF]: {
+  [n.STRING_INDEXOF]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2183,7 +2185,7 @@ const ae = {
       e2.stack.push(o2.indexOf(r2));
     }
   },
-  [i$2.STRING_SPLIT]: {
+  [n.STRING_SPLIT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2201,7 +2203,7 @@ const ae = {
       e2.stack.push(p2);
     }
   },
-  [i$2.STRING_SLICE]: {
+  [n.STRING_SLICE]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -2230,11 +2232,11 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const u2 = c2 !== void 0 ? o2.slice(s2, c2) : o2.slice(s2);
-      e2.stack.push(u2);
+      const i2 = c2 !== void 0 ? o2.slice(s2, c2) : o2.slice(s2);
+      e2.stack.push(i2);
     }
   },
-  [i$2.STRING_CHARAT]: {
+  [n.STRING_CHARAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2257,7 +2259,7 @@ const ae = {
       e2.stack.push(s2);
     }
   },
-  [i$2.STRING_TOUPPERCASE]: {
+  [n.STRING_TOUPPERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2272,7 +2274,7 @@ const ae = {
       e2.stack.push(r2.toUpperCase());
     }
   },
-  [i$2.STRING_TOLOWERCASE]: {
+  [n.STRING_TOLOWERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2287,7 +2289,7 @@ const ae = {
       e2.stack.push(r2.toLowerCase());
     }
   },
-  [i$2.TO_STRING]: {
+  [n.TO_STRING]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -2303,7 +2305,7 @@ const ae = {
       e2.stack.push(o2);
     }
   },
-  [i$2.STRING_INCLUDES]: {
+  [n.STRING_INCLUDES]: {
     stackIn: 2,
     // string, searchString
     stackOut: 1,
@@ -2321,7 +2323,7 @@ const ae = {
       e2.stack.push(o2.includes(s2));
     }
   },
-  [i$2.STRING_ENDS_WITH]: {
+  [n.STRING_ENDS_WITH]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2337,7 +2339,7 @@ const ae = {
       e2.stack.push(o2.endsWith(s2));
     }
   },
-  [i$2.STRING_STARTS_WITH]: {
+  [n.STRING_STARTS_WITH]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2353,7 +2355,7 @@ const ae = {
       e2.stack.push(o2.startsWith(s2));
     }
   },
-  [i$2.STRING_TRIM]: {
+  [n.STRING_TRIM]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2368,7 +2370,7 @@ const ae = {
       e2.stack.push(r2.trim());
     }
   },
-  [i$2.STRING_TRIM_START]: {
+  [n.STRING_TRIM_START]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2383,7 +2385,7 @@ const ae = {
       e2.stack.push(r2.trimStart());
     }
   },
-  [i$2.STRING_TRIM_END]: {
+  [n.STRING_TRIM_END]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2398,7 +2400,7 @@ const ae = {
       e2.stack.push(r2.trimEnd());
     }
   },
-  [i$2.STRING_REPLACE]: {
+  [n.STRING_REPLACE]: {
     stackIn: 3,
     // string, search, replacement
     stackOut: 1,
@@ -2411,11 +2413,11 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const c2 = String(o2), p2 = String(r2), a2 = s2.indexOf(c2), u2 = a2 === -1 ? s2 : s2.substring(0, a2) + p2 + s2.substring(a2 + c2.length);
-      e2.stack.push(u2);
+      const c2 = String(r2), p2 = String(o2), a2 = s2.indexOf(p2), i2 = a2 === -1 ? s2 : s2.substring(0, a2) + c2 + s2.substring(a2 + p2.length);
+      e2.stack.push(i2);
     }
   },
-  [i$2.STRING_REPLACE_ALL]: {
+  [n.STRING_REPLACE_ALL]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2431,7 +2433,7 @@ const ae = {
       e2.stack.push(a2);
     }
   },
-  [i$2.STRING_LAST_INDEX_OF]: {
+  [n.STRING_LAST_INDEX_OF]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2447,7 +2449,7 @@ const ae = {
       e2.stack.push(o2.lastIndexOf(s2));
     }
   },
-  [i$2.STRING_REPEAT]: {
+  [n.STRING_REPEAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2469,7 +2471,7 @@ const ae = {
       e2.stack.push(o2.repeat(Math.floor(r2)));
     }
   },
-  [i$2.STRING_PAD_START]: {
+  [n.STRING_PAD_START]: {
     stackIn: 3,
     // string, targetLength, padString
     stackOut: 1,
@@ -2493,7 +2495,7 @@ const ae = {
       e2.stack.push(s2.padStart(o2, c2 || " "));
     }
   },
-  [i$2.STRING_PAD_END]: {
+  [n.STRING_PAD_END]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2544,7 +2546,7 @@ function A(e2, t2) {
     return e2;
 }
 const le = {
-  [i$2.OBJECT_CREATE]: {
+  [n.OBJECT_CREATE]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
@@ -2552,7 +2554,7 @@ const le = {
       e2.stack.push(r2);
     }
   },
-  [i$2.PROPERTY_SET]: {
+  [n.PROPERTY_SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -2586,7 +2588,7 @@ const le = {
       c2.properties[p2] = r2, e2.stack.push(s2);
     }
   },
-  [i$2.PROPERTY_GET]: {
+  [n.PROPERTY_GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -2622,7 +2624,7 @@ const le = {
       e2.stack.push(c$1 ?? C$1());
     }
   },
-  [i$2.JSON_STRINGIFY]: {
+  [n.JSON_STRINGIFY]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -2632,7 +2634,7 @@ const le = {
       e2.stack.push(JSON.stringify(o2));
     }
   },
-  [i$2.OBJECT_KEYS]: {
+  [n.OBJECT_KEYS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -2653,7 +2655,7 @@ const le = {
     }
   }
 }, de = {
-  [i$2.OBJECT_ITER_START]: {
+  [n.OBJECT_ITER_START]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -2693,7 +2695,7 @@ const le = {
         });
     }
   },
-  [i$2.OBJECT_ITER_NEXT]: {
+  [n.OBJECT_ITER_NEXT]: {
     stackIn: 0,
     stackOut: 2,
     // Push key and hasNext
@@ -2707,7 +2709,7 @@ const le = {
     }
   }
 }, fe = {
-  [i$2.GET]: {
+  [n.GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2727,9 +2729,9 @@ const le = {
         if (i$1(r2))
           a2 = r2;
         else if (t(r2)) {
-          const i2 = parseInt(r2, 10);
-          if (!isNaN(i2) && i2.toString() === r2 && i2 >= 0)
-            a2 = i2;
+          const u2 = parseInt(r2, 10);
+          if (!isNaN(u2) && u2.toString() === r2 && u2 >= 0)
+            a2 = u2;
           else {
             const y2 = ((s2 = p2.properties) == null ? void 0 : s2[r2]) ?? C$1();
             e2.stack.push(y2);
@@ -2742,8 +2744,8 @@ const le = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const u2 = p2.elements[a2] ?? C$1();
-        e2.stack.push(u2);
+        const i2 = p2.elements[a2] ?? C$1();
+        e2.stack.push(i2);
         return;
       } else if (b(o2)) {
         const c2 = e2.heap.get(o2.id);
@@ -2754,8 +2756,8 @@ const le = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const p2 = c2.data, a2 = p$1(r2), u2 = p2.properties[a2] ?? C$1();
-        e2.stack.push(u2);
+        const p2 = c2.data, a2 = p$1(r2), i2 = p2.properties[a2] ?? C$1();
+        e2.stack.push(i2);
         return;
       } else if (t(o2)) {
         let c2;
@@ -2776,7 +2778,7 @@ const le = {
         };
     }
   },
-  [i$2.SET]: {
+  [n.SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2795,9 +2797,9 @@ const le = {
         if (i$1(o2))
           a2 = o2;
         else if (t(o2)) {
-          const i2 = parseInt(o2, 10);
-          if (!isNaN(i2) && i2.toString() === o2 && i2 >= 0)
-            a2 = i2;
+          const u2 = parseInt(o2, 10);
+          if (!isNaN(u2) && u2.toString() === o2 && u2 >= 0)
+            a2 = u2;
           else {
             p2.properties || (p2.properties = {}), p2.properties[o2] = r2, e2.stack.push(s2);
             return;
@@ -2809,15 +2811,15 @@ const le = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const u2 = Math.floor(a2);
-        if (u2 < 0)
+        const i2 = Math.floor(a2);
+        if (i2 < 0)
           return {
             type: "RuntimeError",
             message: "SET: Negative index not allowed",
             pc: e2.pc,
             opcode: t$1.op
           };
-        p2.elements[u2] = r2, e2.stack.push(s2);
+        p2.elements[i2] = r2, e2.stack.push(s2);
         return;
       } else if (b(s2)) {
         const c2 = e2.heap.get(s2.id);
@@ -2917,8 +2919,8 @@ const le = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const i2 = new RegExp(p2, a2).test(r2);
-      e2.stack.push(i2);
+      const u2 = new RegExp(p2, a2).test(r2);
+      e2.stack.push(u2);
       return;
     } catch (c2) {
       return {
@@ -2970,13 +2972,13 @@ const le = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const u2 = new RegExp(p2, a2), i2 = o2.match(u2);
-      if (i2 === null)
+      const i2 = new RegExp(p2, a2), u2 = o2.match(i2);
+      if (u2 === null)
         e2.stack.push(null);
       else {
         const y2 = {
           type: "array",
-          elements: [...i2]
+          elements: [...u2]
           // Copy all match results
         }, E2 = e2.heap.allocate("array", y2);
         e2.stack.push(E2);
@@ -3010,13 +3012,11 @@ const le = {
         pc: e2.pc,
         opcode: t2.op
       };
-    if (!b(o2))
-      return {
-        type: "TypeError",
-        message: "Expected regex object for replace",
-        pc: e2.pc,
-        opcode: t2.op
-      };
+    if (!b(o2)) {
+      const p2 = String(o2), a2 = String(r2), i2 = s2.indexOf(p2), u2 = i2 === -1 ? s2 : s2.substring(0, i2) + a2 + s2.substring(i2 + p2.length);
+      e2.stack.push(u2);
+      return;
+    }
     if (typeof r2 != "string")
       return {
         type: "TypeError",
@@ -3033,15 +3033,15 @@ const le = {
         opcode: t2.op
       };
     try {
-      const p2 = c2.data, a2 = p2.properties.source, u2 = p2.properties.flags;
-      if (typeof a2 != "string" || typeof u2 != "string")
+      const p2 = c2.data, a2 = p2.properties.source, i2 = p2.properties.flags;
+      if (typeof a2 != "string" || typeof i2 != "string")
         return {
           type: "TypeError",
           message: "Invalid regex object structure",
           pc: e2.pc,
           opcode: t2.op
         };
-      const i2 = new RegExp(a2, u2), y2 = s2.replace(i2, r2);
+      const u2 = new RegExp(a2, i2), y2 = s2.replace(u2, r2);
       e2.stack.push(y2);
       return;
     } catch (p2) {
@@ -3054,10 +3054,10 @@ const le = {
     }
   }
 }, he = {
-  [i$2.LOAD_REGEX]: ge,
-  [i$2.REGEX_TEST]: me,
-  [i$2.STRING_MATCH]: ke,
-  [i$2.STRING_REPLACE_REGEX]: ye
+  [n.LOAD_REGEX]: ge,
+  [n.REGEX_TEST]: me,
+  [n.STRING_MATCH]: ke,
+  [n.STRING_REPLACE_REGEX]: ye
 }, F = {
   ...Z,
   ...ee,
@@ -3069,21 +3069,19 @@ const le = {
   ...ne,
   ...pe,
   ...ae,
-  ...ue,
   ...ie,
+  ...ue,
   ...le,
   ...de,
   ...fe,
   ...he
 };
 function w() {
-  const e2 = /* @__PURE__ */ new Map();
-  let t2 = 1;
-  return {
+  const e2 = /* @__PURE__ */ new Map(), t2 = {
     objects: e2,
-    nextId: t2,
+    nextId: 1,
     allocate(r2, o2) {
-      const s2 = t2++, c2 = { id: s2, type: r2, data: o2 };
+      const s2 = t2.nextId++, c2 = { id: s2, type: r2, data: o2 };
       return e2.set(s2, c2), r2 === "array" ? { type: "array-ref", id: s2 } : { type: "object-ref", id: s2 };
     },
     get(r2) {
@@ -3092,6 +3090,7 @@ function w() {
         return o2;
     }
   };
+  return t2;
 }
 class C {
   createInitialState() {
@@ -3120,7 +3119,7 @@ class C {
     if (o2.stack.length < t2.stackIn)
       return {
         type: "StackUnderflow",
-        message: `${i$2[r2.op]}: Stack underflow`,
+        message: `${n[r2.op]}: Stack underflow`,
         pc: o2.pc,
         opcode: r2.op
       };
@@ -3145,26 +3144,26 @@ class C {
           s2.status = "error", s2.error = a2.message;
           break;
         }
-        if ((c2.op === i$2.JUMP || c2.op === i$2.JUMP_IF_FALSE || c2.op === i$2.JUMP_IF || c2.op === i$2.JUMP_IF_TRUE || c2.op === i$2.BREAK || c2.op === i$2.CONTINUE) && c2.arg !== void 0 && c2.arg >= t2.length) {
+        if ((c2.op === n.JUMP || c2.op === n.JUMP_IF_FALSE || c2.op === n.JUMP_IF || c2.op === n.JUMP_IF_TRUE || c2.op === n.BREAK || c2.op === n.CONTINUE) && c2.arg !== void 0 && c2.arg >= t2.length) {
           s2.status = "error";
-          const i2 = c2.op === i$2.JUMP || c2.op === i$2.JUMP_IF_FALSE || c2.op === i$2.JUMP_IF || c2.op === i$2.JUMP_IF_TRUE ? "jump" : c2.op === i$2.BREAK ? "break" : "continue";
-          s2.error = `Invalid ${i2} target: ${c2.arg}`;
+          const u2 = c2.op === n.JUMP || c2.op === n.JUMP_IF_FALSE || c2.op === n.JUMP_IF || c2.op === n.JUMP_IF_TRUE ? "jump" : c2.op === n.BREAK ? "break" : "continue";
+          s2.error = `Invalid ${u2} target: ${c2.arg}`;
           break;
         }
-        const u2 = p2.execute(s2, c2);
-        if (u2) {
-          const i2 = s2.pc + 1;
-          if (i2 < t2.length && t2[i2].op === i$2.CC) {
-            s2.ccPrompt = `ERROR: ${u2.message}. How should I proceed?`, s2.status = "waiting_cc", s2.pc = i2;
+        const i2 = p2.execute(s2, c2);
+        if (i2) {
+          const u2 = s2.pc + 1;
+          if (u2 < t2.length && t2[u2].op === n.CC) {
+            s2.ccPrompt = `ERROR: ${i2.message}. How should I proceed?`, s2.status = "waiting_cc", s2.pc = u2;
             break;
           }
-          s2.status = "error", s2.error = u2.message;
+          s2.status = "error", s2.error = i2.message;
           break;
         }
         p2.controlsPC || s2.pc++;
         continue;
       }
-      s2.status = "error", s2.error = `Unknown opcode: ${i$2[c2.op]}`;
+      s2.status = "error", s2.error = `Unknown opcode: ${n[c2.op]}`;
       break;
     }
     return s2;
@@ -3218,8 +3217,8 @@ class V {
     try {
       const p2 = b__namespace.readdirSync(r2, { withFileTypes: true });
       for (const a2 of p2) {
-        const u2 = r__namespace.join(r2, a2.name), i2 = r__namespace.relative(t2, u2);
-        a2.isSymbolicLink() || s2.filter && !this.matchesPattern(i2, s2.filter) || (o2.push(u2), a2.isDirectory() && s2.recursive && this.listFilesRecursive(t2, u2, o2, s2, c2 + 1));
+        const i2 = r__namespace.join(r2, a2.name), u2 = r__namespace.relative(t2, i2);
+        a2.isSymbolicLink() || s2.filter && !this.matchesPattern(u2, s2.filter) || (o2.push(i2), a2.isDirectory() && s2.recursive && this.listFilesRecursive(t2, i2, o2, s2, c2 + 1));
       }
     } catch {
     }
@@ -3279,8 +3278,12 @@ class Se {
    */
   async loadProgram(t2, r2) {
     const o2 = te$1(r2);
-    if (!o2.success)
-      throw new Error(`Compilation failed: ${o2.errors.join(", ")}`);
+    if (!o2.success) {
+      const c2 = o2.errors.map(
+        (p2) => `${p2.message} at line ${p2.line}, column ${p2.character}`
+      );
+      throw new Error(`Compilation failed: ${c2.join("; ")}`);
+    }
     const s2 = {
       id: t2,
       name: t2,
@@ -3386,8 +3389,8 @@ class Se {
       ccPrompt: void 0
     }, a2 = c2.resume(p2, r2, s2.bytecode, this.fileSystem);
     a2.output.length > 0 && await this.storage.appendOutput(t2, a2.output);
-    const u2 = this.serializeVMState(a2);
-    Object.assign(o2, u2), a2.status === "complete" ? (o2.state = "COMPLETED", a2.returnValue !== void 0 && (o2.returnValue = a2.returnValue), this.vms.delete(t2)) : a2.status === "error" ? (o2.state = "ERROR", o2.error = a2.error, this.vms.delete(t2)) : a2.status === "waiting_cc" ? (o2.state = "AWAITING_COGNITIVE_RESULT", o2.ccPrompt = a2.ccPrompt) : o2.state = "RUNNING", await this.storage.saveExecution(o2);
+    const i2 = this.serializeVMState(a2);
+    Object.assign(o2, i2), a2.status === "complete" ? (o2.state = "COMPLETED", a2.returnValue !== void 0 && (o2.returnValue = a2.returnValue), this.vms.delete(t2)) : a2.status === "error" ? (o2.state = "ERROR", o2.error = a2.error, this.vms.delete(t2)) : a2.status === "waiting_cc" ? (o2.state = "AWAITING_COGNITIVE_RESULT", o2.ccPrompt = a2.ccPrompt) : o2.state = "RUNNING", await this.storage.saveExecution(o2);
   }
   /**
    * Get current execution status
@@ -3594,19 +3597,19 @@ class $ {
       },
       async ({ programId: e2, filePath: r$1 }) => {
         try {
-          const t2 = r.resolve(r$1), n = await promises.readFile(t2, "utf-8");
-          return await this.vmManager.loadProgram(e2, n), {
+          const t2 = r.resolve(r$1), n2 = await promises.readFile(t2, "utf-8");
+          return await this.vmManager.loadProgram(e2, n2), {
             content: [{ type: "text", text: `Program loaded successfully from ${r$1}: ${e2}` }]
           };
         } catch (t2) {
           if (t2 instanceof Error) {
-            const n = t2;
-            if (n.code === "ENOENT")
+            const n2 = t2;
+            if (n2.code === "ENOENT")
               return {
                 content: [{ type: "text", text: `Error: File not found: ${r$1}` }],
                 isError: true
               };
-            if (n.code === "EACCES")
+            if (n2.code === "EACCES")
               return {
                 content: [{ type: "text", text: `Error: Permission denied: ${r$1}` }],
                 isError: true
@@ -3630,9 +3633,9 @@ class $ {
           return await this.vmManager.startExecution(e2, r2), t2 && await this.vmManager.setCurrentExecutionId(r2), {
             content: [{ type: "text", text: `Execution started: ${r2}${t2 ? " (set as current)" : ""}` }]
           };
-        } catch (n) {
+        } catch (n2) {
           return {
-            content: [{ type: "text", text: `Error: ${n instanceof Error ? n.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${n2 instanceof Error ? n2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -3646,12 +3649,12 @@ class $ {
         try {
           let r2 = e2;
           if (!r2) {
-            const n = await this.vmManager.getCurrentExecutionId();
-            if (!n)
+            const n2 = await this.vmManager.getCurrentExecutionId();
+            if (!n2)
               return {
                 content: [{ type: "text", text: "No current execution set. Use list_executions to see available executions." }]
               };
-            r2 = n;
+            r2 = n2;
           }
           const t2 = await this.vmManager.getNext(r2);
           return t2.type === "completed" ? {
@@ -3682,13 +3685,13 @@ class $ {
         try {
           let t2 = e2;
           if (!t2) {
-            const n = await this.vmManager.getCurrentExecutionId();
-            if (!n)
+            const n2 = await this.vmManager.getCurrentExecutionId();
+            if (!n2)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            t2 = n;
+            t2 = n2;
           }
           return await this.vmManager.reportCCResult(t2, r2), {
             content: [{ type: "text", text: "Execution resumed" }]
@@ -3709,13 +3712,13 @@ class $ {
         try {
           let r2 = e2;
           if (!r2) {
-            const n = await this.vmManager.getCurrentExecutionId();
-            if (!n)
+            const n2 = await this.vmManager.getCurrentExecutionId();
+            if (!n2)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            r2 = n;
+            r2 = n2;
           }
           const t2 = await this.vmManager.getExecutionStatus(r2);
           return {
@@ -3733,14 +3736,14 @@ class $ {
       {},
       async () => {
         try {
-          const e2 = await this.vmManager.listExecutions(), r2 = await this.vmManager.getCurrentExecutionId(), t2 = e2.map((n) => ({
-            executionId: n.id,
-            programId: n.programId,
-            state: n.state,
-            created: n.created,
-            isCurrent: n.id === r2,
+          const e2 = await this.vmManager.listExecutions(), r2 = await this.vmManager.getCurrentExecutionId(), t2 = e2.map((n2) => ({
+            executionId: n2.id,
+            programId: n2.programId,
+            state: n2.state,
+            created: n2.created,
+            isCurrent: n2.id === r2,
             summary: {
-              currentPrompt: n.state === "AWAITING_COGNITIVE_RESULT" ? n.ccPrompt : void 0,
+              currentPrompt: n2.state === "AWAITING_COGNITIVE_RESULT" ? n2.ccPrompt : void 0,
               tasksCompleted: 0
               // TODO: Track this in future
             }
@@ -3772,12 +3775,12 @@ class $ {
               };
             r2 = a2;
           }
-          const t2 = await this.vmManager.getExecutionWithAttempts(r2), n = await this.vmManager.getCurrentExecutionId(), c2 = {
+          const t2 = await this.vmManager.getExecutionWithAttempts(r2), n2 = await this.vmManager.getCurrentExecutionId(), c2 = {
             executionId: t2.id,
             programId: t2.programId,
             state: t2.state,
             created: t2.created,
-            isCurrent: t2.id === n,
+            isCurrent: t2.id === n2,
             currentTask: t2.state === "AWAITING_COGNITIVE_RESULT" ? {
               prompt: t2.ccPrompt,
               attempts: t2.attempts || 1,