cvm-server 0.12.0 → 0.14.0

package/main.cjs

@@ -3,7 +3,7 @@ const mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod = require("zod");
 const s$1 = require("typescript");
-const b$2 = require("fs");
+const N$1 = require("fs");
 const r = require("path");
 const mongodb = require("mongodb");
 const promises = require("fs/promises");
@@ -11,31 +11,31 @@ const dotenv = require("dotenv");
 const url = require("url");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 function _interopNamespaceDefault(e2) {
-  const n2 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  const n = 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(n2, k2, d2.get ? d2 : {
+        Object.defineProperty(n, k2, d2.get ? d2 : {
           enumerable: true,
           get: () => e2[k2]
         });
       }
     }
   }
-  n2.default = e2;
-  return Object.freeze(n2);
+  n.default = e2;
+  return Object.freeze(n);
 }
 const s__namespace = /* @__PURE__ */ _interopNamespaceDefault(s$1);
-const b__namespace = /* @__PURE__ */ _interopNamespaceDefault(b$2);
+const N__namespace = /* @__PURE__ */ _interopNamespaceDefault(N$1);
 const r__namespace = /* @__PURE__ */ _interopNamespaceDefault(r);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var E$1 = Object.defineProperty;
-var f$2 = (e2, t2, i2) => t2 in e2 ? E$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: i2 }) : e2[t2] = i2;
-var u$2 = (e2, t2, i2) => f$2(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.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.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.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.JSON_STRINGIFY = "JSON_STRINGIFY", e2.GET = "GET", e2.SET = "SET", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(n || {});
-function R(e2) {
-  const t2 = [], i2 = [];
+var _$1 = Object.defineProperty;
+var I = (e2, t2, n) => t2 in e2 ? _$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: n }) : e2[t2] = n;
+var o$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.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 || {});
+function A(e2) {
+  const t2 = [], n = [];
   let r2 = false;
   const a2 = s__namespace.createSourceFile(
     "program.ts",
@@ -43,30 +43,31 @@ function R(e2) {
     s__namespace.ScriptTarget.Latest,
     true
   );
-  function m2(o2) {
-    if (s__namespace.isFunctionDeclaration(o2) && o2.name && o2.name.text === "main" && (r2 = true, o2.parameters.length > 0 && t2.push("main() must not have parameters")), s__namespace.isCallExpression(o2) && s__namespace.isIdentifier(o2.expression)) {
-      const S = o2.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(S) && t2.push(`Unsupported function: ${S}`);
+  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 c2 = T.expression.text;
+      ["setTimeout", "fetch", "require", "import"].includes(c2) && t2.push(`Unsupported function: ${c2}`);
     }
-    s__namespace.forEachChild(o2, m2);
+    s__namespace.forEachChild(T, m2);
   }
-  return m2(a2), r2 || t2.push("Program must have a main() function"), t2.length === 0 && i2.push({ op: n.HALT }), {
-    bytecode: i2,
+  return m2(a2), r2 || t2.push("Program must have a main() function"), t2.length === 0 && n.push({ op: i$2.HALT }), {
+    bytecode: n,
     errors: t2,
     hasMain: r2
   };
 }
-let p$2 = class p {
+class P {
   constructor() {
-    u$2(this, "bytecode", []);
-    u$2(this, "contextStack", []);
+    o$1(this, "bytecode", []);
+    o$1(this, "contextStack", []);
+    o$1(this, "tempVarCounter", 0);
   }
   /**
    * Emit an instruction and return its index
    */
-  emit(t2, i2) {
+  emit(t2, n) {
     const r2 = this.bytecode.length;
-    return this.bytecode.push({ op: t2, arg: i2 }), r2;
+    return this.bytecode.push({ op: t2, arg: n }), r2;
   }
   /**
    * Get the current address (next instruction index)
@@ -77,14 +78,14 @@ let p$2 = class p {
   /**
    * Patch a jump instruction with the target address
    */
-  patchJump(t2, i2) {
-    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = i2);
+  patchJump(t2, n) {
+    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = n);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(t2, i2) {
-    t2.forEach((r2) => this.patchJump(r2, i2));
+  patchJumps(t2, n) {
+    t2.forEach((r2) => this.patchJump(r2, n));
   }
   /**
    * Push a new jump context onto the stack
@@ -109,9 +110,9 @@ let p$2 = class p {
    */
   findLoopContext() {
     for (let t2 = this.contextStack.length - 1; t2 >= 0; t2--) {
-      const i2 = this.contextStack[t2];
-      if (i2.type === "loop" || i2.type === "foreach")
-        return i2;
+      const n = this.contextStack[t2];
+      if (n.type === "loop" || n.type === "foreach")
+        return n;
     }
     return null;
   }
@@ -133,298 +134,434 @@ let p$2 = class p {
   getUnclosedContexts() {
     return [...this.contextStack];
   }
-};
-const A$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
-  i2(e2.expression);
-  const a2 = t2.emit(n.JUMP_IF_FALSE, -1), m2 = {
+  /**
+   * Generate a unique temporary variable name
+   */
+  generateTempVar() {
+    return `__temp${this.tempVarCounter++}`;
+  }
+}
+const g = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  n(e2.expression);
+  const a2 = t2.emit(i$2.JUMP_IF_FALSE, -1), m2 = {
     type: "if",
     endTargets: []
   };
   if (e2.elseStatement ? m2.elseTarget = a2 : m2.endTargets.push(a2), t2.pushContext(m2), r2(e2.thenStatement), e2.elseStatement) {
-    const S = t2.emit(n.JUMP, -1);
-    m2.endTargets.push(S);
-    const c2 = t2.currentAddress();
-    t2.patchJump(a2, c2), r2(e2.elseStatement);
-  }
-  const o2 = t2.popContext();
-  if (o2) {
+    const c2 = t2.emit(i$2.JUMP, -1);
+    m2.endTargets.push(c2);
     const S = t2.currentAddress();
-    t2.patchJumps(o2.endTargets, S);
+    t2.patchJump(a2, S), r2(e2.elseStatement);
+  }
+  const T = t2.popContext();
+  if (T) {
+    const c2 = t2.currentAddress();
+    t2.patchJumps(T.endTargets, c2);
   }
-}, P$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+}, N = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
   const a2 = t2.currentAddress();
-  i2(e2.expression);
-  const o2 = {
+  n(e2.expression);
+  const T = {
     type: "loop",
-    breakTargets: [t2.emit(n.JUMP_IF_FALSE, -1)],
+    breakTargets: [t2.emit(i$2.JUMP_IF_FALSE, -1)],
     continueTargets: [],
     endTargets: [],
     startAddress: a2
   };
-  t2.pushContext(o2), r2(e2.statement), t2.emit(n.JUMP, a2);
-  const S = t2.popContext();
-  if (S) {
-    const c2 = t2.currentAddress();
-    t2.patchJumps(S.breakTargets || [], c2);
+  t2.pushContext(T), r2(e2.statement), t2.emit(i$2.JUMP, a2);
+  const c2 = t2.popContext();
+  if (c2) {
+    const S = t2.currentAddress();
+    t2.patchJumps(c2.breakTargets || [], S);
   }
-}, h$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+}, h$1 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
   const a2 = e2.initializer, m2 = e2.expression;
-  let o2;
+  let T;
   if (s__namespace.isVariableDeclarationList(a2))
-    o2 = a2.declarations[0].name.getText();
+    T = a2.declarations[0].name.getText();
   else if (s__namespace.isIdentifier(a2))
-    o2 = a2.text;
+    T = a2.text;
   else
     throw new Error("Unsupported for-of variable declaration");
-  i2(m2), t2.emit(n.ITER_START);
-  const S = t2.currentAddress();
-  t2.emit(n.ITER_NEXT);
-  const c2 = t2.emit(n.JUMP_IF_FALSE, -1);
-  t2.emit(n.STORE, o2);
-  const l2 = {
+  n(m2), t2.emit(i$2.ITER_START);
+  const c2 = t2.currentAddress();
+  t2.emit(i$2.ITER_NEXT);
+  const S = t2.emit(i$2.JUMP_IF_FALSE, -1);
+  t2.emit(i$2.STORE, T);
+  const u2 = {
     type: "foreach",
-    breakTargets: [c2],
+    breakTargets: [S],
     continueTargets: [],
     endTargets: [],
-    startAddress: S,
-    iterVariable: o2
+    startAddress: c2,
+    iterVariable: T
   };
-  t2.pushContext(l2), r2(e2.statement), t2.emit(n.JUMP, S);
-  const T = t2.popContext();
-  if (T) {
+  t2.pushContext(u2), r2(e2.statement), t2.emit(i$2.JUMP, c2);
+  const l = t2.popContext();
+  if (l) {
     const x2 = t2.currentAddress();
-    t2.patchJumps(T.breakTargets || [], x2), t2.emit(n.ITER_END);
+    t2.patchJumps(l.breakTargets || [], x2), t2.emit(i$2.ITER_END);
   }
-}, I = (e2, t2, { compileStatement: i2 }) => {
+}, p$2 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  const a2 = e2.initializer, m2 = e2.expression;
+  let T;
+  if (s__namespace.isVariableDeclarationList(a2))
+    T = a2.declarations[0].name.getText();
+  else if (s__namespace.isIdentifier(a2))
+    T = a2.text;
+  else
+    throw new Error("Unsupported for-in variable declaration");
+  n(m2), t2.emit(i$2.OBJECT_ITER_START);
+  const c2 = 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);
+  const u2 = {
+    type: "foreach",
+    breakTargets: [S],
+    continueTargets: [],
+    endTargets: [],
+    startAddress: c2,
+    iterVariable: T
+  };
+  t2.pushContext(u2), r2(e2.statement), t2.emit(i$2.JUMP, c2);
+  const l = t2.popContext();
+  if (l) {
+    const x2 = t2.currentAddress();
+    t2.patchJumps(l.breakTargets || [], x2), t2.emit(i$2.ITER_END);
+  }
+}, U = (e2, t2, { compileExpression: n, 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()));
+    else
+      n(e2.initializer), t2.emit(i$2.POP);
+  const a2 = t2.currentAddress();
+  let m2;
+  e2.condition && (n(e2.condition), m2 = t2.emit(i$2.JUMP_IF_FALSE, -1));
+  const T = {
+    type: "loop",
+    breakTargets: m2 ? [m2] : [],
+    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 c2 = t2.popContext();
+  if (c2) {
+    const S = t2.currentAddress();
+    t2.patchJumps(c2.breakTargets || [], S);
+  }
+}, y$1 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  const a2 = t2.generateTempVar();
+  n(e2.expression), t2.emit(i$2.STORE, a2);
+  const m2 = [], T = [];
+  let c2 = null;
+  if (e2.caseBlock.clauses.forEach((l, x2) => {
+    if (s__namespace.isCaseClause(l)) {
+      t2.emit(i$2.LOAD, a2), n(l.expression), t2.emit(i$2.EQ_STRICT);
+      const R = t2.emit(i$2.JUMP_IF_TRUE, -1);
+      T.push(R);
+    } else s__namespace.isDefaultClause(l) && (c2 = t2.emit(i$2.JUMP, -1));
+  }), c2 === null) {
+    const l = t2.emit(i$2.JUMP, -1);
+    m2.push(l);
+  }
+  let S = 0;
+  e2.caseBlock.clauses.forEach((l, x2) => {
+    if (s__namespace.isCaseClause(l)) {
+      const R = t2.currentAddress();
+      t2.patchJumps([T[S]], R), S++, l.statements.forEach((E2) => {
+        if (s__namespace.isBreakStatement(E2)) {
+          const f3 = t2.emit(i$2.JUMP, -1);
+          m2.push(f3);
+        } else
+          r2(E2);
+      });
+    } else if (s__namespace.isDefaultClause(l)) {
+      const R = t2.currentAddress();
+      c2 !== null && t2.patchJumps([c2], R), l.statements.forEach((E2) => {
+        if (s__namespace.isBreakStatement(E2)) {
+          const f3 = t2.emit(i$2.JUMP, -1);
+          m2.push(f3);
+        } else
+          r2(E2);
+      });
+    }
+  });
+  const u2 = t2.currentAddress();
+  t2.patchJumps(m2, u2);
+}, L$1 = (e2, t2, { compileStatement: n }) => {
   e2.statements.forEach((r2) => {
-    i2(r2);
+    n(r2);
   });
-}, _$1 = (e2, t2, { compileExpression: i2 }) => {
+}, k = (e2, t2, { compileExpression: n }) => {
   const r2 = e2.declarationList.declarations[0];
-  r2.initializer && (i2(r2.initializer), t2.emit(n.STORE, r2.name.getText()));
-}, g = (e2, t2, { compileExpression: i2 }) => {
+  r2.initializer && (n(r2.initializer), t2.emit(i$2.STORE, r2.name.getText()));
+}, D = (e2, t2, { compileExpression: n }) => {
   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(n.LOAD, r2.left.text), i2(r2.right), a2) {
+        switch (t2.emit(i$2.LOAD, r2.left.text), n(r2.right), a2) {
           case s__namespace.SyntaxKind.PlusEqualsToken:
-            t2.emit(n.ADD);
+            t2.emit(i$2.ADD);
             break;
           case s__namespace.SyntaxKind.MinusEqualsToken:
-            t2.emit(n.SUB);
+            t2.emit(i$2.SUB);
             break;
           case s__namespace.SyntaxKind.AsteriskEqualsToken:
-            t2.emit(n.MUL);
+            t2.emit(i$2.MUL);
             break;
           case s__namespace.SyntaxKind.SlashEqualsToken:
-            t2.emit(n.DIV);
+            t2.emit(i$2.DIV);
             break;
           case s__namespace.SyntaxKind.PercentEqualsToken:
-            t2.emit(n.MOD);
+            t2.emit(i$2.MOD);
             break;
         }
-        t2.emit(n.STORE, r2.left.text);
+        t2.emit(i$2.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 (i2(r2.right), s__namespace.isIdentifier(r2.left))
-        t2.emit(n.STORE, r2.left.text);
+      if (n(r2.right), s__namespace.isIdentifier(r2.left))
+        t2.emit(i$2.STORE, r2.left.text);
       else if (s__namespace.isElementAccessExpression(r2.left)) {
         const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(n.STORE, m2), i2(r2.left.expression), i2(r2.left.argumentExpression), t2.emit(n.LOAD, m2), t2.emit(n.ARRAY_SET), t2.emit(n.POP);
+        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);
       } else if (s__namespace.isPropertyAccessExpression(r2.left)) {
         const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(n.STORE, m2), i2(r2.left.expression), t2.emit(n.PUSH, r2.left.name.text), t2.emit(n.LOAD, m2), t2.emit(n.PROPERTY_SET), t2.emit(n.POP);
+        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);
       }
       return;
     }
   }
   s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.arguments.forEach((a2) => {
-    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));
-}, y$1 = (e2, t2, { compileExpression: i2 }) => {
-  e2.expression ? i2(e2.expression) : t2.emit(n.PUSH, null), t2.emit(n.RETURN);
-}, N = (e2, t2, i2) => {
+    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));
+}, G = (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) => {
   const r2 = t2.findLoopContext();
   if (r2) {
-    r2.type === "foreach" && t2.emit(n.ITER_END);
-    const a2 = t2.emit(n.BREAK, -1);
+    r2.type === "foreach" && t2.emit(i$2.ITER_END);
+    const a2 = t2.emit(i$2.BREAK, -1);
     r2.breakTargets = r2.breakTargets || [], r2.breakTargets.push(a2);
   } else
-    i2.reportError(e2, "break statement not in loop");
-}, U = (e2, t2, i2) => {
+    n.reportError(e2, "break statement not in loop");
+}, b$1 = (e2, t2, n) => {
   const r2 = t2.findLoopContext();
   if (r2 && r2.startAddress !== void 0) {
-    const a2 = t2.emit(n.CONTINUE, r2.startAddress);
+    const a2 = t2.emit(i$2.CONTINUE, r2.startAddress);
     r2.continueTargets = r2.continueTargets || [], r2.continueTargets.push(a2);
   } else
-    i2.reportError(e2, "continue statement not in loop");
-}, k = {
-  [s__namespace.SyntaxKind.IfStatement]: A$1,
-  [s__namespace.SyntaxKind.WhileStatement]: P$1,
+    n.reportError(e2, "continue statement not in loop");
+}, K = {
+  [s__namespace.SyntaxKind.IfStatement]: g,
+  [s__namespace.SyntaxKind.WhileStatement]: N,
   [s__namespace.SyntaxKind.ForOfStatement]: h$1,
-  [s__namespace.SyntaxKind.Block]: I,
-  [s__namespace.SyntaxKind.VariableStatement]: _$1,
-  [s__namespace.SyntaxKind.ExpressionStatement]: g,
-  [s__namespace.SyntaxKind.ReturnStatement]: y$1,
-  [s__namespace.SyntaxKind.BreakStatement]: N,
-  [s__namespace.SyntaxKind.ContinueStatement]: U
-}, L = (e2, t2, i2) => {
-  t2.emit(n.PUSH, e2.text);
-}, F$1 = (e2, t2, i2) => {
-  t2.emit(n.PUSH, Number(e2.text));
-}, K$1 = (e2, t2, i2) => {
-  t2.emit(n.PUSH, true);
-}, b$1 = (e2, t2, i2) => {
-  t2.emit(n.PUSH, false);
-}, D$1 = (e2, t2, i2) => {
-  t2.emit(n.PUSH, null);
-}, d$3 = (e2, t2, i2) => {
-  e2.text === "undefined" ? t2.emit(n.PUSH_UNDEFINED) : t2.emit(n.LOAD, e2.text);
-}, G$1 = (e2, t2, { compileExpression: i2 }) => {
-  t2.emit(n.ARRAY_NEW), e2.elements.forEach((r2) => {
-    i2(r2), t2.emit(n.ARRAY_PUSH);
+  [s__namespace.SyntaxKind.ForInStatement]: p$2,
+  [s__namespace.SyntaxKind.ForStatement]: U,
+  [s__namespace.SyntaxKind.SwitchStatement]: y$1,
+  [s__namespace.SyntaxKind.Block]: L$1,
+  [s__namespace.SyntaxKind.VariableStatement]: k,
+  [s__namespace.SyntaxKind.ExpressionStatement]: D,
+  [s__namespace.SyntaxKind.ReturnStatement]: G,
+  [s__namespace.SyntaxKind.BreakStatement]: F$1,
+  [s__namespace.SyntaxKind.ContinueStatement]: b$1
+}, J = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, e2.text);
+}, H = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, Number(e2.text));
+}, M$1 = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, true);
+}, Y = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, false);
+}, B$1 = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, null);
+}, C$2 = (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 });
+}, d$3 = (e2, t2, n) => {
+  e2.text === "undefined" ? t2.emit(i$2.PUSH_UNDEFINED) : t2.emit(i$2.LOAD, e2.text);
+}, w$1 = (e2, t2, { compileExpression: n }) => {
+  t2.emit(i$2.ARRAY_NEW), e2.elements.forEach((r2) => {
+    n(r2), t2.emit(i$2.ARRAY_PUSH);
   });
-}, H$1 = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.expression);
-}, M$2 = (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));
-}, Y = (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);
-}, J = (e2, t2, { compileExpression: i2 }) => {
+}, O = (e2, t2, { compileExpression: n }) => {
+  n(e2.expression);
+}, q = (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 }) => {
   switch (e2.operator) {
     case s__namespace.SyntaxKind.ExclamationToken:
-      i2(e2.operand), t2.emit(n.NOT);
+      n(e2.operand), t2.emit(i$2.NOT);
       break;
     case s__namespace.SyntaxKind.MinusToken:
-      i2(e2.operand), t2.emit(n.UNARY_MINUS);
+      n(e2.operand), t2.emit(i$2.UNARY_MINUS);
       break;
     case s__namespace.SyntaxKind.PlusToken:
-      i2(e2.operand), t2.emit(n.UNARY_PLUS);
+      n(e2.operand), t2.emit(i$2.UNARY_PLUS);
       break;
     case s__namespace.SyntaxKind.PlusPlusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, false));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.INC, false));
       break;
     case s__namespace.SyntaxKind.MinusMinusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, false));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.DEC, false));
       break;
   }
-}, w = (e2, t2, { compileExpression: i2 }) => {
+}, j$2 = (e2, t2, { compileExpression: n }) => {
   switch (e2.operator) {
     case s__namespace.SyntaxKind.PlusPlusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, true));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.INC, true));
       break;
     case s__namespace.SyntaxKind.MinusMinusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, true));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.DEC, true));
       break;
   }
-}, B$1 = (e2, t2, { compileExpression: i2 }) => {
+}, X = (e2, t2, { compileExpression: n }) => {
   const r2 = e2.operatorToken.kind;
-  switch (i2(e2.left), i2(e2.right), r2) {
+  switch (n(e2.left), n(e2.right), r2) {
     case s__namespace.SyntaxKind.PlusToken:
-      t2.emit(n.ADD);
+      t2.emit(i$2.ADD);
       break;
     case s__namespace.SyntaxKind.MinusToken:
-      t2.emit(n.SUB);
+      t2.emit(i$2.SUB);
       break;
     case s__namespace.SyntaxKind.AsteriskToken:
-      t2.emit(n.MUL);
+      t2.emit(i$2.MUL);
       break;
     case s__namespace.SyntaxKind.SlashToken:
-      t2.emit(n.DIV);
+      t2.emit(i$2.DIV);
       break;
     case s__namespace.SyntaxKind.PercentToken:
-      t2.emit(n.MOD);
+      t2.emit(i$2.MOD);
       break;
     case s__namespace.SyntaxKind.EqualsEqualsToken:
-      t2.emit(n.EQ);
+      t2.emit(i$2.EQ);
       break;
     case s__namespace.SyntaxKind.ExclamationEqualsToken:
-      t2.emit(n.NEQ);
+      t2.emit(i$2.NEQ);
       break;
     case s__namespace.SyntaxKind.LessThanToken:
-      t2.emit(n.LT);
+      t2.emit(i$2.LT);
       break;
     case s__namespace.SyntaxKind.GreaterThanToken:
-      t2.emit(n.GT);
+      t2.emit(i$2.GT);
       break;
     case s__namespace.SyntaxKind.LessThanEqualsToken:
-      t2.emit(n.LTE);
+      t2.emit(i$2.LTE);
       break;
     case s__namespace.SyntaxKind.GreaterThanEqualsToken:
-      t2.emit(n.GTE);
+      t2.emit(i$2.GTE);
       break;
     case s__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-      t2.emit(n.EQ_STRICT);
+      t2.emit(i$2.EQ_STRICT);
       break;
     case s__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-      t2.emit(n.NEQ_STRICT);
+      t2.emit(i$2.NEQ_STRICT);
       break;
     case s__namespace.SyntaxKind.AmpersandAmpersandToken:
-      t2.emit(n.AND);
+      t2.emit(i$2.AND);
       break;
     case s__namespace.SyntaxKind.BarBarToken:
-      t2.emit(n.OR);
+      t2.emit(i$2.OR);
       break;
   }
-}, q = (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), m2 = t2.currentAddress();
-  t2.patchJump(r2, m2), i2(e2.whenFalse);
-  const o2 = t2.currentAddress();
-  t2.patchJump(a2, o2);
-}, C$1 = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.expression), t2.emit(n.TYPEOF);
-}, O$1 = (e2, t2, { compileExpression: i2, reportError: r2 }) => {
+}, v = (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 }) => {
   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 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, "."), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.FS_LIST_FILES);
+      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);
     else if (a2 === "readFile")
-      e2.arguments.length > 0 ? (i2(e2.arguments[0]), t2.emit(n.FS_READ_FILE)) : r2(e2, "fs.readFile() requires a path argument");
+      e2.arguments.length > 0 ? (n(e2.arguments[0]), t2.emit(i$2.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;
       }
-      i2(e2.arguments[0]), i2(e2.arguments[1]), t2.emit(n.FS_WRITE_FILE);
+      n(e2.arguments[0]), n(e2.arguments[1]), t2.emit(i$2.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 && i2(e2.arguments[0]), t2.emit(n.JSON_PARSE);
+    e2.arguments.length > 0 && n(e2.arguments[0]), t2.emit(i$2.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 ? i2(e2.arguments[0]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.JSON_STRINGIFY);
-  else if (s__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
-    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(n.CC);
+    e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH_UNDEFINED), t2.emit(i$2.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);
+  } else if (s__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
+    e2.arguments.length > 0 && n(e2.arguments[0]), t2.emit(i$2.CC);
   else if (s__namespace.isPropertyAccessExpression(e2.expression)) {
     const a2 = e2.expression.name.text;
     if (a2 === "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);
+      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);
     else if (a2 === "indexOf")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_INDEXOF);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_INDEXOF);
     else if (a2 === "split")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_SPLIT);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_SPLIT);
     else if (a2 === "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.STRING_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);
+    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);
     else if (a2 === "charAt")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), t2.emit(n.STRING_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);
     else if (a2 === "toUpperCase")
-      i2(e2.expression.expression), t2.emit(n.STRING_TOUPPERCASE);
+      n(e2.expression.expression), t2.emit(i$2.STRING_TOUPPERCASE);
     else if (a2 === "toLowerCase")
-      i2(e2.expression.expression), t2.emit(n.STRING_TOLOWERCASE);
+      n(e2.expression.expression), t2.emit(i$2.STRING_TOLOWERCASE);
     else if (a2 === "toString")
-      i2(e2.expression.expression), t2.emit(n.TO_STRING);
+      n(e2.expression.expression), t2.emit(i$2.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);
+    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);
+    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);
+    else if (a2 === "trim")
+      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM);
+    else if (a2 === "trimStart")
+      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM_START);
+    else if (a2 === "trimEnd")
+      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM_END);
+    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, ""), t2.emit(i$2.STRING_REPLACE);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
     else
       throw new Error(`Method call '${a2}' is not supported`);
   } else
     throw new Error("Unsupported call expression");
-}, V = (e2, t2, { compileExpression: i2 }) => {
-  t2.emit(n.OBJECT_CREATE);
+}, $$1 = (e2, t2, { compileExpression: n }) => {
+  t2.emit(i$2.OBJECT_CREATE);
   for (const r2 of e2.properties)
     if (s__namespace.isPropertyAssignment(r2)) {
       let a2;
@@ -434,92 +571,93 @@ const A$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
         a2 = r2.name.text;
       else
         throw new Error("Computed property names are not supported");
-      t2.emit(n.PUSH, a2), i2(r2.initializer), t2.emit(n.PROPERTY_SET);
+      t2.emit(i$2.PUSH, a2), n(r2.initializer), t2.emit(i$2.PROPERTY_SET);
     } else if (s__namespace.isShorthandPropertyAssignment(r2)) {
       const a2 = r2.name.text;
-      t2.emit(n.PUSH, a2), t2.emit(n.LOAD, a2), t2.emit(n.PROPERTY_SET);
+      t2.emit(i$2.PUSH, a2), t2.emit(i$2.LOAD, a2), t2.emit(i$2.PROPERTY_SET);
     } else
       throw new Error("Unsupported property type in object literal");
-}, W$1 = {
-  [s__namespace.SyntaxKind.StringLiteral]: L,
-  [s__namespace.SyntaxKind.NumericLiteral]: F$1,
-  [s__namespace.SyntaxKind.TrueKeyword]: K$1,
-  [s__namespace.SyntaxKind.FalseKeyword]: b$1,
-  [s__namespace.SyntaxKind.NullKeyword]: D$1,
+}, Z$1 = {
+  [s__namespace.SyntaxKind.StringLiteral]: J,
+  [s__namespace.SyntaxKind.NumericLiteral]: H,
+  [s__namespace.SyntaxKind.TrueKeyword]: M$1,
+  [s__namespace.SyntaxKind.FalseKeyword]: Y,
+  [s__namespace.SyntaxKind.NullKeyword]: B$1,
+  [s__namespace.SyntaxKind.RegularExpressionLiteral]: C$2,
   [s__namespace.SyntaxKind.Identifier]: d$3,
-  [s__namespace.SyntaxKind.ArrayLiteralExpression]: G$1,
-  [s__namespace.SyntaxKind.BinaryExpression]: B$1,
-  [s__namespace.SyntaxKind.PrefixUnaryExpression]: J,
-  [s__namespace.SyntaxKind.PostfixUnaryExpression]: w,
-  [s__namespace.SyntaxKind.CallExpression]: O$1,
-  [s__namespace.SyntaxKind.PropertyAccessExpression]: M$2,
-  [s__namespace.SyntaxKind.ElementAccessExpression]: Y,
-  [s__namespace.SyntaxKind.ConditionalExpression]: q,
-  [s__namespace.SyntaxKind.TypeOfExpression]: C$1,
-  [s__namespace.SyntaxKind.ParenthesizedExpression]: H$1,
-  [s__namespace.SyntaxKind.ObjectLiteralExpression]: V
+  [s__namespace.SyntaxKind.ArrayLiteralExpression]: w$1,
+  [s__namespace.SyntaxKind.BinaryExpression]: X,
+  [s__namespace.SyntaxKind.PrefixUnaryExpression]: W$1,
+  [s__namespace.SyntaxKind.PostfixUnaryExpression]: j$2,
+  [s__namespace.SyntaxKind.CallExpression]: Q$1,
+  [s__namespace.SyntaxKind.PropertyAccessExpression]: q,
+  [s__namespace.SyntaxKind.ElementAccessExpression]: V$1,
+  [s__namespace.SyntaxKind.ConditionalExpression]: v,
+  [s__namespace.SyntaxKind.TypeOfExpression]: z,
+  [s__namespace.SyntaxKind.ParenthesizedExpression]: O,
+  [s__namespace.SyntaxKind.ObjectLiteralExpression]: $$1
 };
-function j$2(e2) {
-  const t2 = [], i2 = R(e2);
-  if (i2.errors.length > 0)
+function te$1(e2) {
+  const t2 = [], n = A(e2);
+  if (n.errors.length > 0)
     return {
       success: false,
       bytecode: [],
-      errors: i2.errors.map((c2) => ({
-        message: c2,
+      errors: n.errors.map((S) => ({
+        message: S,
         line: 0,
         character: 0
       }))
     };
-  const r2 = new p$2(), a2 = s__namespace.createSourceFile("program.ts", e2, s__namespace.ScriptTarget.Latest, true), m2 = {
-    compileStatement: o2,
-    compileExpression: S,
-    reportError: (c2, l2) => {
-      const { line: T, character: x2 } = a2.getLineAndCharacterOfPosition(c2.getStart());
+  const r2 = new P(), a2 = s__namespace.createSourceFile("program.ts", e2, s__namespace.ScriptTarget.Latest, true), m2 = {
+    compileStatement: T,
+    compileExpression: c2,
+    reportError: (S, u2) => {
+      const { line: l, character: x2 } = a2.getLineAndCharacterOfPosition(S.getStart());
       throw t2.push({
-        message: l2,
-        line: T + 1,
+        message: u2,
+        line: l + 1,
         // TypeScript uses 0-based lines
         character: x2 + 1
         // TypeScript uses 0-based columns
-      }), new Error(l2);
+      }), new Error(u2);
     }
   };
-  function o2(c2) {
-    const l2 = k[c2.kind];
-    if (l2)
-      l2(c2, r2, m2);
+  function T(S) {
+    const u2 = K[S.kind];
+    if (u2)
+      u2(S, r2, m2);
     else {
-      const { line: T, character: x2 } = a2.getLineAndCharacterOfPosition(c2.getStart());
+      const { line: l, character: x2 } = a2.getLineAndCharacterOfPosition(S.getStart());
       t2.push({
-        message: `Unsupported statement: ${s__namespace.SyntaxKind[c2.kind]}`,
-        line: T + 1,
+        message: `Unsupported statement: ${s__namespace.SyntaxKind[S.kind]}`,
+        line: l + 1,
         character: x2 + 1
       });
     }
   }
-  function S(c2) {
-    const l2 = W$1[c2.kind];
-    if (l2)
-      l2(c2, r2, m2);
+  function c2(S) {
+    const u2 = Z$1[S.kind];
+    if (u2)
+      u2(S, r2, m2);
     else {
-      const { line: T, character: x2 } = a2.getLineAndCharacterOfPosition(c2.getStart());
+      const { line: l, character: x2 } = a2.getLineAndCharacterOfPosition(S.getStart());
       t2.push({
-        message: `Unsupported expression: ${s__namespace.SyntaxKind[c2.kind]}`,
-        line: T + 1,
+        message: `Unsupported expression: ${s__namespace.SyntaxKind[S.kind]}`,
+        line: l + 1,
         character: x2 + 1
       });
     }
   }
-  return a2.forEachChild((c2) => {
-    var l2;
-    s__namespace.isFunctionDeclaration(c2) && ((l2 = c2.name) == null ? void 0 : l2.text) === "main" && c2.body && c2.body.statements.forEach((T) => {
+  return a2.forEachChild((S) => {
+    var u2;
+    s__namespace.isFunctionDeclaration(S) && ((u2 = S.name) == null ? void 0 : u2.text) === "main" && S.body && S.body.statements.forEach((l) => {
       try {
-        o2(T);
+        T(l);
       } catch {
       }
     });
-  }), r2.emit(n.HALT), {
+  }), r2.emit(i$2.HALT), {
     success: t2.length === 0,
     bytecode: r2.getBytecode(),
     errors: t2
@@ -534,7 +672,7 @@ function i$1(r2) {
 function e(r2) {
   return typeof r2 == "boolean";
 }
-function f$1(r2) {
+function f$2(r2) {
   return r2 === null;
 }
 function o(r2) {
@@ -553,38 +691,38 @@ function b(r2) {
   return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "object-ref";
 }
 function p$1(r2) {
-  return t(r2) ? r2 : i$1(r2) || e(r2) ? r2.toString() : f$1(r2) ? "null" : c(r2) ? "undefined" : o(r2) ? `[array:${r2.elements.length}]` : y(r2) ? "[object Object]" : String(r2);
+  return t(r2) ? r2 : i$1(r2) || e(r2) ? r2.toString() : f$2(r2) ? "null" : c(r2) ? "undefined" : o(r2) ? `[array:${r2.elements.length}]` : y(r2) ? "[object Object]" : String(r2);
 }
 function j$1(r2) {
-  return e(r2) ? r2 : f$1(r2) || c(r2) ? false : i$1(r2) ? r2 !== 0 : t(r2) ? r2 !== "" : o(r2) || y(r2) ? true : !!r2;
+  return e(r2) ? r2 : f$2(r2) || c(r2) ? false : i$1(r2) ? r2 !== 0 : t(r2) ? r2 !== "" : o(r2) || y(r2) ? true : !!r2;
 }
 function d$2(r2) {
-  return t(r2) ? "string" : i$1(r2) ? "number" : e(r2) ? "boolean" : f$1(r2) ? "null" : c(r2) ? "undefined" : o(r2) || u$1(r2) ? "array" : y(r2) || b(r2) ? "object" : "unknown";
+  return t(r2) ? "string" : i$1(r2) ? "number" : e(r2) ? "boolean" : f$2(r2) ? "null" : c(r2) ? "undefined" : o(r2) || u$1(r2) ? "array" : y(r2) || b(r2) ? "object" : "unknown";
 }
 function m(r2) {
   if (i$1(r2)) return r2;
   if (e(r2)) return r2 ? 1 : 0;
-  if (f$1(r2)) return 0;
+  if (f$2(r2)) return 0;
   if (c(r2)) return NaN;
   if (t(r2)) {
-    const n2 = r2.trim();
-    return n2 === "" ? 0 : Number(n2);
+    const n = r2.trim();
+    return n === "" ? 0 : Number(n);
   }
   return o(r2) ? NaN : Number(r2);
 }
-function s(r2 = [], n2) {
-  return n2 ? { type: "array", elements: r2, properties: n2 } : { type: "array", elements: r2 };
+function s(r2 = [], n) {
+  return n ? { type: "array", elements: r2, properties: n } : { type: "array", elements: r2 };
 }
-function C() {
+function C$1() {
   return { type: "undefined" };
 }
-function M$1(r2 = {}) {
+function M(r2 = {}) {
   return { type: "object", properties: r2 };
 }
 var d$1 = Object.defineProperty;
-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 p2 {
+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);
+class p {
   constructor(t2) {
     a(this, "connected", false);
     a(this, "programsDir");
@@ -596,7 +734,7 @@ class p2 {
     return r__namespace.join(this.dataDir, "metadata.json");
   }
   async connect() {
-    await b$2.promises.mkdir(this.dataDir, { recursive: true }), await b$2.promises.mkdir(this.programsDir, { recursive: true }), await b$2.promises.mkdir(this.executionsDir, { recursive: true }), await b$2.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
+    await N$1.promises.mkdir(this.dataDir, { recursive: true }), await N$1.promises.mkdir(this.programsDir, { recursive: true }), await N$1.promises.mkdir(this.executionsDir, { recursive: true }), await N$1.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
   }
   async disconnect() {
     this.connected = false;
@@ -606,14 +744,14 @@ class p2 {
   }
   async saveProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    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");
+    const n = r__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await N$1.promises.writeFile(n, e2, "utf-8");
   }
   async getProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
+    const n = r__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      const e2 = await b$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await N$1.promises.readFile(n, "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")
@@ -623,14 +761,14 @@ class p2 {
   }
   async saveExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    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");
+    const n = r__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await N$1.promises.writeFile(n, e2, "utf-8");
   }
   async getExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
+    const n = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      const e2 = await b$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await N$1.promises.readFile(n, "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")
@@ -638,18 +776,18 @@ class p2 {
       throw e2;
     }
   }
-  async appendOutput(t2, n2) {
+  async appendOutput(t2, n) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
+    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`), o2 = n.join(`
 `) + `
 `;
-    await b$2.promises.appendFile(e2, o2, "utf-8");
+    await N$1.promises.appendFile(e2, o2, "utf-8");
   }
   async getOutput(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.outputsDir, `${t2}.output`);
+    const n = r__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      return (await b$2.promises.readFile(n2, "utf-8")).split(`
+      return (await N$1.promises.readFile(n, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -659,18 +797,18 @@ class p2 {
   }
   async listExecutions() {
     if (!this.connected) throw new Error("Not connected");
-    const t2 = await b$2.promises.readdir(this.executionsDir), n2 = [];
+    const t2 = await N$1.promises.readdir(this.executionsDir), n = [];
     for (const e2 of t2)
       if (e2.endsWith(".json")) {
         const o2 = e2.slice(0, -5), i2 = await this.getExecution(o2);
-        i2 && n2.push(i2);
+        i2 && n.push(i2);
       }
-    return n2;
+    return n;
   }
   async getCurrentExecutionId() {
     if (!this.connected) throw new Error("Not connected");
     try {
-      const t2 = await b$2.promises.readFile(this.metadataFile, "utf-8");
+      const t2 = await N$1.promises.readFile(this.metadataFile, "utf-8");
       return JSON.parse(t2).currentExecutionId || null;
     } catch (t2) {
       if (t2.code === "ENOENT")
@@ -680,20 +818,20 @@ class p2 {
   }
   async setCurrentExecutionId(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = { currentExecutionId: t2 };
-    await b$2.promises.writeFile(this.metadataFile, JSON.stringify(n2, null, 2), "utf-8");
+    const n = { currentExecutionId: t2 };
+    await N$1.promises.writeFile(this.metadataFile, JSON.stringify(n, null, 2), "utf-8");
   }
   async deleteExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
+    const n = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      await b$2.promises.unlink(n2);
+      await N$1.promises.unlink(n);
     } catch (i2) {
       if (i2.code !== "ENOENT") throw i2;
     }
     const e2 = r__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      await b$2.promises.unlink(e2);
+      await N$1.promises.unlink(e2);
     } catch (i2) {
       if (i2.code !== "ENOENT") throw i2;
     }
@@ -701,25 +839,25 @@ class p2 {
   }
   async listPrograms() {
     if (!this.connected) throw new Error("Not connected");
-    const t2 = await b$2.promises.readdir(this.programsDir), n2 = [];
+    const t2 = await N$1.promises.readdir(this.programsDir), n = [];
     for (const e2 of t2)
       if (e2.endsWith(".json")) {
         const o2 = e2.slice(0, -5), i2 = await this.getProgram(o2);
-        i2 && n2.push(i2);
+        i2 && n.push(i2);
       }
-    return n2;
+    return n;
   }
   async deleteProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
+    const n = r__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      await b$2.promises.unlink(n2);
+      await N$1.promises.unlink(n);
     } catch (e2) {
       if (e2.code !== "ENOENT") throw e2;
     }
   }
 }
-class f {
+let f$1 = class f {
   constructor(t2) {
     a(this, "client");
     a(this, "db", null);
@@ -742,7 +880,7 @@ class f {
   }
   async getCollections() {
     if (!this.db) throw new Error("Not connected to database");
-    return (await this.db.listCollections().toArray()).map((n2) => n2.name);
+    return (await this.db.listCollections().toArray()).map((n) => n.name);
   }
   getCollection(t2) {
     if (!this.db) throw new Error("Not connected to database");
@@ -768,12 +906,12 @@ class f {
   async getExecution(t2) {
     return await this.getCollection("executions").findOne({ id: t2 });
   }
-  async appendOutput(t2, n2) {
+  async appendOutput(t2, n) {
     const e2 = this.getCollection("outputs");
     await e2.findOne({ executionId: t2 }) ? await e2.updateOne(
       { executionId: t2 },
-      { $push: { lines: { $each: n2 } } }
-    ) : await e2.insertOne({ executionId: t2, lines: n2 });
+      { $push: { lines: { $each: n } } }
+    ) : await e2.insertOne({ executionId: t2, lines: n });
   }
   async getOutput(t2) {
     const e2 = await this.getCollection("outputs").findOne({ executionId: t2 });
@@ -783,8 +921,8 @@ class f {
     return await this.getCollection("executions").find({}).toArray();
   }
   async getCurrentExecutionId() {
-    const n2 = await this.getCollection("metadata").findOne({ _id: "current" });
-    return (n2 == null ? void 0 : n2.currentExecutionId) || null;
+    const n = await this.getCollection("metadata").findOne({ _id: "current" });
+    return (n == null ? void 0 : n.currentExecutionId) || null;
   }
   async setCurrentExecutionId(t2) {
     await this.getCollection("metadata").replaceOne(
@@ -795,7 +933,7 @@ class f {
   }
   async deleteExecution(t2) {
     var o2;
-    let n2 = true;
+    let n = true;
     const e2 = this.client.startSession();
     try {
       await e2.withTransaction(async () => {
@@ -807,13 +945,13 @@ class f {
       });
     } catch (i2) {
       if ((o2 = i2 == null ? void 0 : i2.message) != null && o2.includes("Transaction numbers are only allowed"))
-        n2 = false;
+        n = false;
       else
         throw i2;
     } finally {
       await e2.endSession();
     }
-    n2 || (await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null));
+    n || (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();
@@ -821,88 +959,88 @@ class f {
   async deleteProgram(t2) {
     await this.getCollection("programs").deleteOne({ id: t2 });
   }
-}
+};
 class E {
   static create(t2) {
-    const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
-    switch (n2) {
+    const n = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
+    switch (n) {
       case "file": {
         const e2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
-        return new p2(e2);
+        return new p(e2);
       }
       case "mongodb": {
         const e2 = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
-        return new f(e2);
+        return new f$1(e2);
       }
       default:
-        throw new Error(`Unsupported storage type: ${n2}`);
+        throw new Error(`Unsupported storage type: ${n}`);
     }
   }
 }
-var H = Object.defineProperty;
-var D = (e2, t2, r2) => t2 in e2 ? H(e2, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t2] = r2;
-var _ = (e2, t2, r2) => D(e2, typeof t2 != "symbol" ? t2 + "" : t2, r2);
-function z(e2) {
+var B = Object.defineProperty;
+var W = (e2, t2, r2) => t2 in e2 ? B(e2, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t2] = r2;
+var _ = (e2, t2, r2) => W(e2, typeof t2 != "symbol" ? t2 + "" : t2, r2);
+function Q(e2) {
   return !!(e2 && typeof e2 == "object" && "type" in e2 && "message" in e2);
 }
-function l(e2, t2) {
+function d(e2, t2) {
   return e2.stack.length < 1 ? {
     type: "RuntimeError",
     message: "Stack underflow",
     pc: e2.pc,
-    opcode: t2 || n.POP
+    opcode: t2 || i$2.POP
   } : e2.stack.pop();
 }
-const d = z, B = {
-  [n.ADD]: {
+const f2 = Q, Z = {
+  [i$2.ADD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t$1.op);
-      if (d(o2)) return o2;
-      if (t(o2) || t(r2))
-        e2.stack.push(p$1(o2) + p$1(r2));
+      const r2 = d(e2, t$1.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t$1.op);
+      if (f2(s2)) return s2;
+      if (t(s2) || t(r2))
+        e2.stack.push(p$1(s2) + p$1(r2));
       else {
-        const s2 = m(o2), c2 = m(r2);
-        e2.stack.push(s2 + c2);
+        const o2 = m(s2), c2 = m(r2);
+        e2.stack.push(o2 + c2);
       }
     }
   },
-  [n.SUB]: {
+  [i$2.SUB]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
-      e2.stack.push(s2 - c2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
+      e2.stack.push(o2 - c2);
     }
   },
-  [n.MUL]: {
+  [i$2.MUL]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
-      e2.stack.push(s2 * c2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
+      e2.stack.push(o2 * c2);
     }
   },
-  [n.DIV]: {
+  [i$2.DIV]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
       if (c2 === 0)
         return {
           type: "DivisionByZero",
@@ -910,64 +1048,64 @@ const d = z, B = {
           pc: e2.pc,
           opcode: t2.op
         };
-      e2.stack.push(s2 / c2);
+      e2.stack.push(o2 / c2);
     }
   },
-  [n.MOD]: {
+  [i$2.MOD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
-      e2.stack.push(s2 % c2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
+      e2.stack.push(o2 % c2);
     }
   },
-  [n.UNARY_MINUS]: {
+  [i$2.UNARY_MINUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = m(r2);
-      e2.stack.push(-o2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = m(r2);
+      e2.stack.push(-s2);
     }
   },
-  [n.UNARY_PLUS]: {
+  [i$2.UNARY_PLUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = m(r2);
-      e2.stack.push(o2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = m(r2);
+      e2.stack.push(s2);
     }
   }
-}, W = {
-  [n.PUSH]: {
+}, ee = {
+  [i$2.PUSH]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
       e2.stack.push(t2.arg);
     }
   },
-  [n.PUSH_UNDEFINED]: {
+  [i$2.PUSH_UNDEFINED]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
-      e2.stack.push(C());
+      e2.stack.push(C$1());
     }
   },
-  [n.POP]: {
+  [i$2.POP]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
       e2.stack.pop();
     }
   },
-  [n.DUP]: {
+  [i$2.DUP]: {
     stackIn: 1,
     stackOut: 2,
     execute: (e2, t2) => {
@@ -975,24 +1113,24 @@ const d = z, B = {
       e2.stack.push(r2), e2.stack.push(r2);
     }
   },
-  [n.SWAP]: {
+  [i$2.SWAP]: {
     stackIn: 2,
     stackOut: 2,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      e2.stack.push(r2), e2.stack.push(o2);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      e2.stack.push(r2), e2.stack.push(s2);
     }
   },
-  [n.DUP2]: {
+  [i$2.DUP2]: {
     stackIn: 2,
     stackOut: 4,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      e2.stack.push(o2), e2.stack.push(r2), e2.stack.push(o2), e2.stack.push(r2);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      e2.stack.push(s2), e2.stack.push(r2), e2.stack.push(s2), e2.stack.push(r2);
     }
   }
-}, X = {
-  [n.PRINT]: {
+}, re = {
+  [i$2.PRINT]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
@@ -1000,7 +1138,7 @@ const d = z, B = {
       t2 !== void 0 && e2.output.push(p$1(t2));
     }
   },
-  [n.CC]: {
+  [i$2.CC]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1010,8 +1148,8 @@ const d = z, B = {
       e2.ccPrompt = p$1(r2), e2.status = "waiting_cc";
     }
   }
-}, K = {
-  [n.HALT]: {
+}, te = {
+  [i$2.HALT]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1019,7 +1157,7 @@ const d = z, B = {
       e2.status = "complete";
     }
   },
-  [n.JUMP]: {
+  [i$2.JUMP]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1042,7 +1180,7 @@ const d = z, B = {
       e2.pc = r2;
     }
   },
-  [n.JUMP_IF_FALSE]: {
+  [i$2.JUMP_IF_FALSE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1055,18 +1193,18 @@ const d = z, B = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = t2.arg;
-      if (o2 < 0)
+      const s2 = t2.arg;
+      if (s2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${o2}`,
+          message: `Invalid jump target: ${s2}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      j$1(r2) ? e2.pc++ : e2.pc = o2;
+      j$1(r2) ? e2.pc++ : e2.pc = s2;
     }
   },
-  [n.JUMP_IF]: {
+  [i$2.JUMP_IF]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1079,18 +1217,18 @@ const d = z, B = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = t2.arg;
-      if (o2 < 0)
+      const s2 = t2.arg;
+      if (s2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${o2}`,
+          message: `Invalid jump target: ${s2}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      j$1(r2) ? e2.pc = o2 : e2.pc++;
+      j$1(r2) ? e2.pc = s2 : e2.pc++;
     }
   },
-  [n.JUMP_IF_TRUE]: {
+  [i$2.JUMP_IF_TRUE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1103,18 +1241,18 @@ const d = z, B = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = t2.arg;
-      if (o2 < 0)
+      const s2 = t2.arg;
+      if (s2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${o2}`,
+          message: `Invalid jump target: ${s2}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      j$1(r2) ? e2.pc = o2 : e2.pc++;
+      j$1(r2) ? e2.pc = s2 : e2.pc++;
     }
   },
-  [n.CALL]: {
+  [i$2.CALL]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: false,
@@ -1122,19 +1260,19 @@ const d = z, B = {
       type: "RuntimeError",
       message: "Functions not implemented",
       pc: e2.pc,
-      opcode: n.CALL
+      opcode: i$2.CALL
     })
   }
-}, Q = {
-  [n.LOAD]: {
+}, se = {
+  [i$2.LOAD]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
       const r2 = t2.arg;
-      e2.variables.has(r2) ? e2.stack.push(e2.variables.get(r2)) : e2.stack.push(C());
+      e2.variables.has(r2) ? e2.stack.push(e2.variables.get(r2)) : e2.stack.push(C$1());
     }
   },
-  [n.STORE]: {
+  [i$2.STORE]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1142,8 +1280,8 @@ const d = z, B = {
       e2.variables.set(t2.arg, r2);
     }
   }
-}, Z = {
-  [n.ITER_START]: {
+}, oe = {
+  [i$2.ITER_START]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1155,19 +1293,19 @@ const d = z, B = {
           pc: e2.pc,
           opcode: t2.op
         };
-      let o$1;
+      let s2;
       if (u$1(r2)) {
-        const s2 = e2.heap.get(r2.id);
-        if (!s2 || s2.type !== "array")
+        const o2 = e2.heap.get(r2.id);
+        if (!o2 || o2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t2.op
           };
-        o$1 = s2.data;
+        s2 = o2.data;
       } else if (o(r2))
-        o$1 = r2;
+        s2 = r2;
       else
         return {
           type: "TypeError",
@@ -1183,13 +1321,13 @@ const d = z, B = {
           opcode: t2.op
         };
       e2.iterators.push({
-        array: o$1,
+        array: s2,
         index: 0,
-        length: o$1.elements.length
+        length: s2.elements.length
       });
     }
   },
-  [n.ITER_NEXT]: {
+  [i$2.ITER_NEXT]: {
     stackIn: 0,
     stackOut: 2,
     // Pushes element and hasMore flag
@@ -1202,10 +1340,10 @@ const d = z, B = {
           opcode: t2.op
         };
       const r2 = e2.iterators[e2.iterators.length - 1];
-      r2.index < r2.length ? (r2.index < r2.array.elements.length ? e2.stack.push(r2.array.elements[r2.index]) : e2.stack.push(C()), e2.stack.push(true), r2.index++) : (e2.stack.push(null), e2.stack.push(false));
+      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));
     }
   },
-  [n.ITER_END]: {
+  [i$2.ITER_END]: {
     stackIn: 0,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1220,149 +1358,149 @@ const d = z, B = {
     }
   }
 };
-function O(e2, t2, r2) {
-  const o2 = l(e2, t2.op);
-  if (d(o2)) return o2;
-  const s2 = l(e2, t2.op);
-  if (d(s2)) return s2;
-  const c2 = r2(s2, o2);
+function x$1(e2, t2, r2) {
+  const s2 = d(e2, t2.op);
+  if (f2(s2)) return s2;
+  const o2 = d(e2, t2.op);
+  if (f2(o2)) return o2;
+  const c2 = r2(o2, s2);
   e2.stack.push(c2);
 }
-const ee = {
-  [n.EQ]: {
+const ce = {
+  [i$2.EQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
-      if (f$1(r2) && c(o2) || c(r2) && f$1(o2))
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      if (f$2(r2) && c(s2) || c(r2) && f$2(s2))
         return true;
-      if (c(r2) && c(o2))
+      if (c(r2) && c(s2))
         return true;
       if (u$1(r2) || b(r2))
-        return u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id === o2.id : false;
+        return u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id === s2.id : false;
       {
-        const s2 = m(r2), c2 = m(o2);
-        return !isNaN(s2) && !isNaN(c2) ? s2 === c2 : p$1(r2) === p$1(o2);
+        const o2 = m(r2), c2 = m(s2);
+        return !isNaN(o2) && !isNaN(c2) ? o2 === c2 : p$1(r2) === p$1(s2);
       }
     })
   },
-  [n.NEQ]: {
+  [i$2.NEQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
-      if (f$1(r2) && c(o2) || c(r2) && f$1(o2))
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      if (f$2(r2) && c(s2) || c(r2) && f$2(s2))
         return false;
-      if (c(r2) && c(o2))
+      if (c(r2) && c(s2))
         return false;
       if (u$1(r2) || b(r2))
-        return u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id !== o2.id : true;
+        return u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id !== s2.id : true;
       {
-        const s2 = m(r2), c2 = m(o2);
-        return !isNaN(s2) && !isNaN(c2) ? s2 !== c2 : p$1(r2) !== p$1(o2);
+        const o2 = m(r2), c2 = m(s2);
+        return !isNaN(o2) && !isNaN(c2) ? o2 !== c2 : p$1(r2) !== p$1(s2);
       }
     })
   },
-  [n.LT]: {
+  [i$2.LT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 < c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 < c2;
     })
   },
-  [n.GT]: {
+  [i$2.GT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 > c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 > c2;
     })
   },
-  [n.LTE]: {
+  [i$2.LTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 <= c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 <= c2;
     })
   },
-  [n.GTE]: {
+  [i$2.GTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 >= c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 >= c2;
     })
   },
-  [n.EQ_STRICT]: {
+  [i$2.EQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id === o2.id : r2 === o2)
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id === s2.id : r2 === s2)
   },
-  [n.NEQ_STRICT]: {
+  [i$2.NEQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => O(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id !== o2.id : r2 !== o2)
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id !== s2.id : r2 !== s2)
   }
-}, re = {
-  [n.AND]: {
+}, ne = {
+  [i$2.AND]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      const s2 = j$1(o2) ? r2 : o2;
-      e2.stack.push(s2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = j$1(s2) ? r2 : s2;
+      e2.stack.push(o2);
     }
   },
-  [n.OR]: {
+  [i$2.OR]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      const s2 = j$1(o2) ? o2 : r2;
-      e2.stack.push(s2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = j$1(s2) ? s2 : r2;
+      e2.stack.push(o2);
     }
   },
-  [n.NOT]: {
+  [i$2.NOT]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = !j$1(r2);
-      e2.stack.push(o2);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = !j$1(r2);
+      e2.stack.push(s2);
     }
   }
-}, te = {
+}, pe = {
   /**
    * ARRAY_NEW: Creates a new empty array on the heap
    * Stack: [] -> [array-ref]
    */
-  [n.ARRAY_NEW]: {
+  [i$2.ARRAY_NEW]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = s(), o2 = e2.heap.allocate("array", r2);
-      e2.stack.push(o2);
+      const r2 = s(), s$12 = e2.heap.allocate("array", r2);
+      e2.stack.push(s$12);
     }
   },
   /**
    * ARRAY_PUSH: Pushes a value to the end of an array
    * Stack: [array-ref, value] -> [array-ref]
    */
-  [n.ARRAY_PUSH]: {
+  [i$2.ARRAY_PUSH]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o$1 = e2.stack.pop();
-      let s2;
-      if (u$1(o$1)) {
-        const c2 = e2.heap.get(o$1.id);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      let o$12;
+      if (u$1(s2)) {
+        const c2 = e2.heap.get(s2.id);
         if (!c2 || c2.type !== "array")
           return {
             type: "RuntimeError",
@@ -1370,9 +1508,9 @@ const ee = {
             pc: e2.pc,
             opcode: t2.op
           };
-        s2 = c2.data;
-      } else if (o(o$1))
-        s2 = o$1;
+        o$12 = c2.data;
+      } else if (o(s2))
+        o$12 = s2;
       else
         return {
           type: "RuntimeError",
@@ -1380,49 +1518,49 @@ const ee = {
           pc: e2.pc,
           opcode: t2.op
         };
-      s2.elements.push(r2), e2.stack.push(o$1);
+      o$12.elements.push(r2), e2.stack.push(s2);
     }
   },
-  [n.ARRAY_GET]: {
+  [i$2.ARRAY_GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      var u2;
-      const r2 = e2.stack.pop(), o$1 = e2.stack.pop();
-      let s2;
-      if (u$1(o$1)) {
-        const a2 = e2.heap.get(o$1.id);
-        if (!a2 || a2.type !== "array")
+      var a2;
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      let o$12;
+      if (u$1(s2)) {
+        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
           };
-        s2 = a2.data;
-      } else if (b(o$1)) {
-        const a2 = e2.heap.get(o$1.id);
-        if (!a2 || a2.type !== "object")
+        o$12 = i2.data;
+      } else if (b(s2)) {
+        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 = a2.data, E2 = p$1(r2), x2 = i2.properties[E2] ?? C();
-        e2.stack.push(x2);
+        const u2 = i2.data, y2 = p$1(r2), E2 = u2.properties[y2] ?? C$1();
+        e2.stack.push(E2);
         return;
-      } else if (o(o$1))
-        s2 = o$1;
-      else if (t(o$1)) {
-        let a2;
+      } else if (o(s2))
+        o$12 = s2;
+      else if (t(s2)) {
+        let i2;
         if (i$1(r2))
-          a2 = r2;
+          i2 = r2;
         else if (t(r2)) {
-          const i2 = parseInt(r2, 10);
-          !isNaN(i2) && i2.toString() === r2 && (a2 = i2);
+          const u2 = parseInt(r2, 10);
+          !isNaN(u2) && u2.toString() === r2 && (i2 = u2);
         }
-        a2 !== void 0 && a2 >= 0 && a2 < o$1.length ? e2.stack.push(o$1[a2]) : e2.stack.push(C());
+        i2 !== void 0 && i2 >= 0 && i2 < s2.length ? e2.stack.push(s2[i2]) : e2.stack.push(C$1());
         return;
       } else
         return {
@@ -1435,12 +1573,12 @@ const ee = {
       if (i$1(r2))
         c2 = r2;
       else if (t(r2)) {
-        const a2 = parseInt(r2, 10);
-        if (!isNaN(a2) && a2.toString() === r2 && a2 >= 0)
-          c2 = a2;
+        const i2 = parseInt(r2, 10);
+        if (!isNaN(i2) && i2.toString() === r2 && i2 >= 0)
+          c2 = i2;
         else {
-          const i2 = ((u2 = s2.properties) == null ? void 0 : u2[r2]) ?? C();
-          e2.stack.push(i2);
+          const u2 = ((a2 = o$12.properties) == null ? void 0 : a2[r2]) ?? C$1();
+          e2.stack.push(u2);
           return;
         }
       } else
@@ -1450,40 +1588,40 @@ const ee = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const p3 = s2.elements[c2] ?? C();
-      e2.stack.push(p3);
+      const p2 = o$12.elements[c2] ?? C$1();
+      e2.stack.push(p2);
     }
   },
-  [n.ARRAY_SET]: {
+  [i$2.ARRAY_SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o$1 = e2.stack.pop(), s2 = e2.stack.pop();
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o$12 = e2.stack.pop();
       let c2;
-      if (u$1(s2)) {
-        const a2 = e2.heap.get(s2.id);
-        if (!a2 || a2.type !== "array")
+      if (u$1(o$12)) {
+        const i2 = e2.heap.get(o$12.id);
+        if (!i2 || i2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        c2 = a2.data;
-      } else if (b(s2)) {
-        const a2 = e2.heap.get(s2.id);
-        if (!a2 || a2.type !== "object")
+        c2 = i2.data;
+      } else if (b(o$12)) {
+        const i2 = e2.heap.get(o$12.id);
+        if (!i2 || i2.type !== "object")
           return {
             type: "RuntimeError",
             message: "Invalid object reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        const i2 = a2.data, E2 = p$1(o$1);
-        i2.properties[E2] = r2, e2.stack.push(s2);
+        const u2 = i2.data, y2 = p$1(s2);
+        u2.properties[y2] = r2, e2.stack.push(o$12);
         return;
-      } else if (o(s2))
-        c2 = s2;
+      } else if (o(o$12))
+        c2 = o$12;
       else
         return {
           type: "RuntimeError",
@@ -1491,15 +1629,15 @@ const ee = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      let p3;
-      if (i$1(o$1))
-        p3 = o$1;
-      else if (t(o$1)) {
-        const a2 = parseInt(o$1, 10);
-        if (!isNaN(a2) && a2.toString() === o$1 && a2 >= 0)
-          p3 = a2;
+      let p2;
+      if (i$1(s2))
+        p2 = s2;
+      else if (t(s2)) {
+        const i2 = parseInt(s2, 10);
+        if (!isNaN(i2) && i2.toString() === s2 && i2 >= 0)
+          p2 = i2;
         else {
-          c2.properties || (c2.properties = {}), c2.properties[o$1] = r2, e2.stack.push(s2);
+          c2.properties || (c2.properties = {}), c2.properties[s2] = r2, e2.stack.push(o$12);
           return;
         }
       } else
@@ -1509,35 +1647,35 @@ const ee = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const u2 = Math.floor(p3);
-      if (u2 < 0)
+      const a2 = Math.floor(p2);
+      if (a2 < 0)
         return {
           type: "RuntimeError",
           message: "ARRAY_SET: Negative index not allowed",
           pc: e2.pc,
           opcode: t$1.op
         };
-      c2.elements[u2] = r2, e2.stack.push(s2);
+      c2.elements[a2] = r2, e2.stack.push(o$12);
     }
   },
-  [n.ARRAY_LEN]: {
+  [i$2.ARRAY_LEN]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
       const r2 = e2.stack.pop();
-      let o$1;
+      let s2;
       if (u$1(r2)) {
-        const s2 = e2.heap.get(r2.id);
-        if (!s2 || s2.type !== "array")
+        const o2 = e2.heap.get(r2.id);
+        if (!o2 || o2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t2.op
           };
-        o$1 = s2.data;
+        s2 = o2.data;
       } else if (o(r2))
-        o$1 = r2;
+        s2 = r2;
       else
         return {
           type: "RuntimeError",
@@ -1545,116 +1683,189 @@ const ee = {
           pc: e2.pc,
           opcode: t2.op
         };
-      e2.stack.push(o$1.elements.length);
+      e2.stack.push(s2.elements.length);
     }
   },
-  [n.ARRAY_MAP_PROP]: {
+  [i$2.ARRAY_MAP_PROP]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!u$1(o2))
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop();
+      if (!u$1(s$12))
         return {
           type: "RuntimeError",
           message: "map() requires an array",
           pc: e2.pc,
           opcode: t2.op
         };
-      const s$12 = e2.heap.get(o2.id);
-      if (!s$12 || s$12.type !== "array")
+      const o2 = e2.heap.get(s$12.id);
+      if (!o2 || o2.type !== "array")
         return {
           type: "RuntimeError",
           message: "Invalid array reference",
           pc: e2.pc,
           opcode: t2.op
         };
-      const c2 = s$12.data, p3 = s();
-      for (const a2 of c2.elements)
-        if (b(a2)) {
-          const i2 = e2.heap.get(a2.id);
-          if (i2 && i2.type === "object") {
-            const E2 = i2.data, x2 = p$1(r2);
-            p3.elements.push(E2.properties[x2] || null);
+      const c2 = o2.data, p2 = s();
+      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
-            p3.elements.push(null);
+            p2.elements.push(null);
         } else
-          p3.elements.push(null);
-      const u2 = e2.heap.allocate("array", p3);
-      e2.stack.push(u2);
+          p2.elements.push(null);
+      const a2 = e2.heap.allocate("array", p2);
+      e2.stack.push(a2);
     }
   },
-  [n.ARRAY_FILTER_PROP]: {
+  [i$2.ARRAY_FILTER_PROP]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!u$1(o2))
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop();
+      if (!u$1(s$12))
         return {
           type: "RuntimeError",
           message: "filter() requires an array",
           pc: e2.pc,
           opcode: t2.op
         };
-      const s$12 = e2.heap.get(o2.id);
-      if (!s$12 || s$12.type !== "array")
+      const o2 = e2.heap.get(s$12.id);
+      if (!o2 || o2.type !== "array")
         return {
           type: "RuntimeError",
           message: "Invalid array reference",
           pc: e2.pc,
           opcode: t2.op
         };
-      const c2 = s$12.data, p3 = s();
-      for (const a2 of c2.elements)
-        if (b(a2)) {
-          const i2 = e2.heap.get(a2.id);
-          if (i2 && i2.type === "object") {
-            const E2 = i2.data, x2 = p$1(r2);
-            x2 in E2.properties && E2.properties[x2] && p3.elements.push(a2);
+      const c2 = o2.data, p2 = s();
+      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 u2 = e2.heap.allocate("array", p3);
+      const a2 = e2.heap.allocate("array", p2);
+      e2.stack.push(a2);
+    }
+  },
+  [i$2.ARRAY_SLICE]: {
+    stackIn: 3,
+    // array, start, end
+    stackOut: 1,
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!((M2) => {
+        if (!u$1(M2))
+          return false;
+        const U2 = e2.heap.get(M2.id);
+        return U2 !== void 0 && U2.type === "array";
+      })(o2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_SLICE requires an array",
+          pc: e2.pc,
+          opcode: t2.op
+        };
+      const a2 = e2.heap.get(o2.id).data, i2 = i$1(s$12) ? s$12 : 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]: {
+    stackIn: 2,
+    // array, separator
+    stackOut: 1,
+    // string
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!((y2) => {
+        if (!u$1(y2))
+          return false;
+        const E2 = e2.heap.get(y2.id);
+        return E2 !== void 0 && E2.type === "array";
+      })(s2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_JOIN requires an array",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const p2 = e2.heap.get(s2.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]: {
+    stackIn: 2,
+    // array, searchElement
+    stackOut: 1,
+    // number (index or -1)
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!((a2) => {
+        if (!u$1(a2))
+          return false;
+        const i2 = e2.heap.get(a2.id);
+        return i2 !== void 0 && i2.type === "array";
+      })(s2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_INDEX_OF requires an array",
+          pc: e2.pc,
+          opcode: t2.op
+        };
+      const p2 = e2.heap.get(s2.id).data;
+      for (let a2 = 0; a2 < p2.elements.length; a2++)
+        if (p2.elements[a2] === r2) {
+          e2.stack.push(a2);
+          return;
+        }
+      e2.stack.push(-1);
+    }
   }
 };
-function M(e2, t2) {
+function L(e2, t2) {
   if (e2 === null) return null;
   if (e2 !== void 0) {
     if (typeof e2 == "string" || typeof e2 == "number" || typeof e2 == "boolean" || e2 && typeof e2 == "object" && e2.type === "array" && Array.isArray(e2.elements))
       return e2;
     if (Array.isArray(e2)) {
       const r2 = s();
-      return r2.elements = e2.map((o2) => M(o2, t2)), t2.allocate("array", r2);
+      return r2.elements = e2.map((s2) => L(s2, t2)), t2.allocate("array", r2);
     }
     if (e2 && typeof e2 == "object" && e2.type === "object" && e2.properties)
       return e2;
     if (typeof e2 == "object") {
-      const r2 = M$1();
-      for (const [o2, s2] of Object.entries(e2))
-        r2.properties[o2] = M(s2, t2);
+      const r2 = M();
+      for (const [s2, o2] of Object.entries(e2))
+        r2.properties[s2] = L(o2, t2);
       return t2.allocate("object", r2);
     }
     return null;
   }
 }
-const oe = {
-  [n.CONCAT]: {
+const ae = {
+  [i$2.CONCAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      e2.stack.push(p$1(o2) + p$1(r2));
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      e2.stack.push(p$1(s2) + p$1(r2));
     }
   },
-  [n.STRING_LEN]: {
+  [i$2.STRING_LEN]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
-      if (d(r2)) return r2;
+      const r2 = d(e2, t$1.op);
+      if (f2(r2)) return r2;
       if (!t(r2))
         return {
           type: "RuntimeError",
@@ -1665,27 +1876,27 @@ const oe = {
       e2.stack.push(r2.length);
     }
   },
-  [n.LENGTH]: {
+  [i$2.LENGTH]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
-      if (d(r2)) return r2;
+      const r2 = d(e2, t$1.op);
+      if (f2(r2)) return r2;
       if (t(r2))
         e2.stack.push(r2.length);
       else if (o(r2))
         e2.stack.push(r2.elements.length);
       else if (u$1(r2)) {
-        const o2 = e2.heap.get(r2.id);
-        if (!o2 || o2.type !== "array")
+        const s2 = e2.heap.get(r2.id);
+        if (!s2 || s2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        const s2 = o2.data;
-        e2.stack.push(s2.elements.length);
+        const o2 = s2.data;
+        e2.stack.push(o2.elements.length);
       } else
         return {
           type: "RuntimeError",
@@ -1695,12 +1906,12 @@ const oe = {
         };
     }
   },
-  [n.JSON_PARSE]: {
+  [i$2.JSON_PARSE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
-      if (d(r2)) return r2;
+      const r2 = d(e2, t$1.op);
+      if (f2(r2)) return r2;
       if (!t(r2))
         return {
           type: "RuntimeError",
@@ -1709,24 +1920,24 @@ const oe = {
           opcode: t$1.op
         };
       try {
-        const o2 = JSON.parse(r2);
-        e2.stack.push(M(o2, e2.heap));
+        const s2 = JSON.parse(r2);
+        e2.stack.push(L(s2, e2.heap));
       } catch {
         e2.stack.push(null);
       }
     }
   },
-  [n.TYPEOF]: {
+  [i$2.TYPEOF]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
       e2.stack.push(d$2(r2));
     }
   }
-}, se = {
-  [n.INC]: {
+}, ie = {
+  [i$2.INC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1738,13 +1949,13 @@ const oe = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = e2.variables.get(r2) ?? 0, s2 = m(o2) + 1;
-      e2.variables.set(r2, s2);
+      const s2 = e2.variables.get(r2) ?? 0, o2 = m(s2) + 1;
+      e2.variables.set(r2, o2);
       const c2 = t2.arg === true;
-      e2.stack.push(c2 ? m(o2) : s2);
+      e2.stack.push(c2 ? m(s2) : o2);
     }
   },
-  [n.DEC]: {
+  [i$2.DEC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1756,14 +1967,14 @@ const oe = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = e2.variables.get(r2) ?? 0, s2 = m(o2) - 1;
-      e2.variables.set(r2, s2);
+      const s2 = e2.variables.get(r2) ?? 0, o2 = m(s2) - 1;
+      e2.variables.set(r2, o2);
       const c2 = t2.arg === true;
-      e2.stack.push(c2 ? m(o2) : s2);
+      e2.stack.push(c2 ? m(s2) : o2);
     }
   }
-}, ce = {
-  [n.RETURN]: {
+}, ue = {
+  [i$2.RETURN]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1772,7 +1983,7 @@ const oe = {
       e2.returnValue = r2, e2.status = "complete";
     }
   },
-  [n.BREAK]: {
+  [i$2.BREAK]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1795,7 +2006,7 @@ const oe = {
       e2.pc = r2;
     }
   },
-  [n.CONTINUE]: {
+  [i$2.CONTINUE]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1818,7 +2029,7 @@ const oe = {
       e2.pc = r2;
     }
   },
-  [n.FS_LIST_FILES]: {
+  [i$2.FS_LIST_FILES]: {
     stackIn: 1,
     // Minimum 1 argument (path), optionally 2 (path + options)
     stackOut: 1,
@@ -1830,9 +2041,9 @@ const oe = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      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$1 = e2.stack.pop()), r2 = e2.stack.pop(), !t(r2))
+      let r2, s2 = {};
+      const o$12 = e2.stack[e2.stack.length - 1];
+      if (e2.stack.length >= 2 && typeof o$12 == "object" && o$12 !== null && !o(o$12) && (s2 = e2.stack.pop()), r2 = e2.stack.pop(), !t(r2))
         return {
           type: "RuntimeError",
           message: "FS_LIST_FILES requires a string path",
@@ -1846,15 +2057,15 @@ const oe = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const c2 = e2.fileSystem.listFiles(r2, o$1);
+      const c2 = e2.fileSystem.listFiles(r2, s2);
       if (o(c2)) {
-        const p3 = e2.heap.allocate("array", c2);
-        e2.stack.push(p3);
+        const p2 = e2.heap.allocate("array", c2);
+        e2.stack.push(p2);
       } else
         e2.stack.push(c2);
     }
   },
-  [n.FS_READ_FILE]: {
+  [i$2.FS_READ_FILE]: {
     stackIn: 1,
     // path
     stackOut: 1,
@@ -1875,18 +2086,18 @@ const oe = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const o2 = e2.fileSystem.readFile(r2);
-      e2.stack.push(o2);
+      const s2 = e2.fileSystem.readFile(r2);
+      e2.stack.push(s2);
     }
   },
-  [n.FS_WRITE_FILE]: {
+  [i$2.FS_WRITE_FILE]: {
     stackIn: 2,
     // path, content
     stackOut: 1,
     // Returns boolean
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!o2 || !t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!s2 || !t(s2))
         return {
           type: "RuntimeError",
           message: "FS_WRITE_FILE requires a string path",
@@ -1907,12 +2118,12 @@ const oe = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = p$1(r2), c2 = e2.fileSystem.writeFile(o2, s2);
+      const o2 = p$1(r2), c2 = e2.fileSystem.writeFile(s2, o2);
       e2.stack.push(c2);
     }
   },
   // String method handlers
-  [n.STRING_SUBSTRING]: {
+  [i$2.STRING_SUBSTRING]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -1925,62 +2136,62 @@ const oe = {
           opcode: t$1.op
         };
       const r2 = e2.stack.length;
-      let o2, s2, c2;
-      const p3 = e2.stack[r2 - 1], u2 = e2.stack[r2 - 2];
-      if (r2 >= 3 && typeof p3 == "number" && typeof u2 == "number" ? (c2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop()) : (s2 = e2.stack.pop(), o2 = e2.stack.pop(), c2 = void 0), !t(o2))
+      let s2, o2, c2;
+      const p2 = e2.stack[r2 - 1], a2 = e2.stack[r2 - 2];
+      if (r2 >= 3 && typeof p2 == "number" && typeof a2 == "number" ? (c2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = void 0), !t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      if (typeof s2 != "number")
+      if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires numeric start index",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const a2 = o2.length;
-      s2 < 0 && (s2 = Math.max(0, a2 + s2)), c2 !== void 0 && c2 < 0 && (c2 = Math.max(0, a2 + c2));
-      const i2 = c2 !== void 0 ? o2.substring(s2, c2) : o2.substring(s2);
-      e2.stack.push(i2);
+      const i2 = s2.length;
+      o2 < 0 && (o2 = Math.max(0, i2 + o2)), c2 !== void 0 && c2 < 0 && (c2 = Math.max(0, i2 + c2));
+      const u2 = c2 !== void 0 ? s2.substring(o2, c2) : s2.substring(o2);
+      e2.stack.push(u2);
     }
   },
-  [n.STRING_INDEXOF]: {
+  [i$2.STRING_INDEXOF]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2) || !t(r2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2) || !t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_INDEXOF requires string arguments",
           pc: e2.pc,
           opcode: t$1.op
         };
-      e2.stack.push(o2.indexOf(r2));
+      e2.stack.push(s2.indexOf(r2));
     }
   },
-  [n.STRING_SPLIT]: {
+  [i$2.STRING_SPLIT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2) || !t(r2))
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop();
+      if (!t(s$12) || !t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_SPLIT requires string arguments",
           pc: e2.pc,
           opcode: t$1.op
         };
-      let s$12;
-      r2 === "" ? s$12 = o2.split("") : s$12 = o2.split(r2);
-      const c2 = s(s$12), p3 = e2.heap.allocate("array", c2);
-      e2.stack.push(p3);
+      let o2;
+      r2 === "" ? o2 = s$12.split("") : o2 = s$12.split(r2);
+      const c2 = s(o2), p2 = e2.heap.allocate("array", c2);
+      e2.stack.push(p2);
     }
   },
-  [n.STRING_SLICE]: {
+  [i$2.STRING_SLICE]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -1993,32 +2204,32 @@ const oe = {
           opcode: t$1.op
         };
       const r2 = e2.stack.length;
-      let o2, s2, c2;
-      const p3 = e2.stack.length >= 1 ? e2.stack[r2 - 1] : void 0, u2 = e2.stack.length >= 2 ? e2.stack[r2 - 2] : void 0;
-      if (r2 >= 3 && typeof p3 == "number" && typeof u2 == "number" ? (c2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop()) : (s2 = e2.stack.pop(), o2 = e2.stack.pop(), c2 = void 0), !t(o2))
+      let s2, o2, c2;
+      const p2 = e2.stack.length >= 1 ? e2.stack[r2 - 1] : void 0, a2 = e2.stack.length >= 2 ? e2.stack[r2 - 2] : void 0;
+      if (r2 >= 3 && typeof p2 == "number" && typeof a2 == "number" ? (c2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = void 0), !t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      if (typeof s2 != "number")
+      if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires numeric start index",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const a2 = c2 !== void 0 ? o2.slice(s2, c2) : o2.slice(s2);
-      e2.stack.push(a2);
+      const i2 = c2 !== void 0 ? s2.slice(o2, c2) : s2.slice(o2);
+      e2.stack.push(i2);
     }
   },
-  [n.STRING_CHARAT]: {
+  [i$2.STRING_CHARAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_CHARAT requires a string",
@@ -2032,11 +2243,11 @@ const oe = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = o2.charAt(r2);
-      e2.stack.push(s2);
+      const o2 = s2.charAt(r2);
+      e2.stack.push(o2);
     }
   },
-  [n.STRING_TOUPPERCASE]: {
+  [i$2.STRING_TOUPPERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2051,7 +2262,7 @@ const oe = {
       e2.stack.push(r2.toUpperCase());
     }
   },
-  [n.STRING_TOLOWERCASE]: {
+  [i$2.STRING_TOLOWERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2066,7 +2277,7 @@ const oe = {
       e2.stack.push(r2.toLowerCase());
     }
   },
-  [n.TO_STRING]: {
+  [i$2.TO_STRING]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -2078,23 +2289,236 @@ const oe = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = p$1(r2);
-      e2.stack.push(o2);
+      const s2 = p$1(r2);
+      e2.stack.push(s2);
+    }
+  },
+  [i$2.STRING_INCLUDES]: {
+    stackIn: 2,
+    // string, searchString
+    stackOut: 1,
+    // boolean
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_INCLUDES requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const o2 = String(r2);
+      e2.stack.push(s2.includes(o2));
+    }
+  },
+  [i$2.STRING_ENDS_WITH]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_ENDS_WITH requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const o2 = String(r2);
+      e2.stack.push(s2.endsWith(o2));
+    }
+  },
+  [i$2.STRING_STARTS_WITH]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_STARTS_WITH requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const o2 = String(r2);
+      e2.stack.push(s2.startsWith(o2));
+    }
+  },
+  [i$2.STRING_TRIM]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop();
+      if (!t(r2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_TRIM requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      e2.stack.push(r2.trim());
+    }
+  },
+  [i$2.STRING_TRIM_START]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop();
+      if (!t(r2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_TRIM_START requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      e2.stack.push(r2.trimStart());
+    }
+  },
+  [i$2.STRING_TRIM_END]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop();
+      if (!t(r2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_TRIM_END requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      e2.stack.push(r2.trimEnd());
+    }
+  },
+  [i$2.STRING_REPLACE]: {
+    stackIn: 3,
+    // string, search, replacement
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_REPLACE requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const c2 = String(s2), p2 = String(r2), a2 = o2.indexOf(c2), i2 = a2 === -1 ? o2 : o2.substring(0, a2) + p2 + o2.substring(a2 + c2.length);
+      e2.stack.push(i2);
+    }
+  },
+  [i$2.STRING_REPLACE_ALL]: {
+    stackIn: 3,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_REPLACE_ALL requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const c2 = String(s2), p2 = String(r2), a2 = o2.split(c2).join(p2);
+      e2.stack.push(a2);
+    }
+  },
+  [i$2.STRING_LAST_INDEX_OF]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_LAST_INDEX_OF requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const o2 = String(r2);
+      e2.stack.push(s2.lastIndexOf(o2));
+    }
+  },
+  [i$2.STRING_REPEAT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_REPEAT requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      if (!i$1(r2) || r2 < 0)
+        return {
+          type: "RuntimeError",
+          message: "STRING_REPEAT requires non-negative number",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      e2.stack.push(s2.repeat(Math.floor(r2)));
+    }
+  },
+  [i$2.STRING_PAD_START]: {
+    stackIn: 3,
+    // string, targetLength, padString
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_PAD_START requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      if (!i$1(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_PAD_START requires number for length",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const c2 = t(r2) ? r2 : String(r2);
+      e2.stack.push(o2.padStart(s2, c2 || " "));
+    }
+  },
+  [i$2.STRING_PAD_END]: {
+    stackIn: 3,
+    stackOut: 1,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_PAD_END requires a string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      if (!i$1(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_PAD_END requires number for length",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const c2 = t(r2) ? r2 : String(r2);
+      e2.stack.push(o2.padEnd(s2, c2 || " "));
     }
   }
 };
 function j(e2, t2) {
   if (u$1(e2)) {
     const r2 = t2.get(e2.id);
-    return r2 && r2.type === "array" ? r2.data.elements.map((s2) => j(s2, t2)) : null;
+    return r2 && r2.type === "array" ? r2.data.elements.map((o2) => j(o2, t2)) : null;
   }
   if (b(e2)) {
     const r2 = t2.get(e2.id);
     if (r2 && r2.type === "object") {
-      const o2 = r2.data, s2 = {};
-      for (const [c2, p3] of Object.entries(o2.properties))
-        s2[c2] = j(p3, t2);
-      return s2;
+      const s2 = r2.data, o2 = {};
+      for (const [c2, p2] of Object.entries(s2.properties))
+        o2[c2] = j(p2, t2);
+      return o2;
     }
     return null;
   }
@@ -2102,111 +2526,185 @@ function j(e2, t2) {
     return e2.elements.map((r2) => j(r2, t2));
   if (y(e2)) {
     const r2 = {};
-    for (const [o2, s2] of Object.entries(e2.properties))
-      r2[o2] = j(s2, t2);
+    for (const [s2, o2] of Object.entries(e2.properties))
+      r2[s2] = j(o2, t2);
     return r2;
   }
   if (!c(e2))
     return e2;
 }
-const ne = {
-  [n.OBJECT_CREATE]: {
+const le = {
+  [i$2.OBJECT_CREATE]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
-      const t2 = M$1(), r2 = e2.heap.allocate("object", t2);
+      const t2 = M(), r2 = e2.heap.allocate("object", t2);
       e2.stack.push(r2);
     }
   },
-  [n.PROPERTY_SET]: {
+  [i$2.PROPERTY_SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      const s2 = l(e2, t2.op);
-      if (d(s2)) return s2;
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = d(e2, t2.op);
+      if (f2(o2)) return o2;
       let c2;
-      if (b(s2)) {
-        const u2 = e2.heap.get(s2.id);
-        if (!u2 || u2.type !== "object")
+      if (b(o2)) {
+        const a2 = e2.heap.get(o2.id);
+        if (!a2 || a2.type !== "object")
           return {
             type: "RuntimeError",
             message: "Invalid object reference",
             pc: e2.pc,
             opcode: t2.op
           };
-        c2 = u2.data;
-      } else if (y(s2))
-        c2 = s2;
+        c2 = a2.data;
+      } else if (y(o2))
+        c2 = o2;
       else
         return {
           type: "RuntimeError",
-          message: `Cannot set property '${o2}' on ${d$2(s2)}`,
+          message: `Cannot set property '${s2}' on ${d$2(o2)}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      const p3 = p$1(o2);
-      c2.properties[p3] = r2, e2.stack.push(s2);
+      const p2 = p$1(s2);
+      c2.properties[p2] = r2, e2.stack.push(o2);
     }
   },
-  [n.PROPERTY_GET]: {
+  [i$2.PROPERTY_GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (d(o2)) return o2;
-      if (f$1(o2) || c(o2))
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      if (f$2(s2) || c(s2))
         return {
           type: "RuntimeError",
-          message: `Cannot read property '${r2}' of ${d$2(o2)}`,
+          message: `Cannot read property '${r2}' of ${d$2(s2)}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      let s2 = null;
-      if (b(o2)) {
-        const p3 = e2.heap.get(o2.id);
-        if (!p3 || p3.type !== "object")
+      let o2 = null;
+      if (b(s2)) {
+        const p2 = e2.heap.get(s2.id);
+        if (!p2 || p2.type !== "object")
           return {
             type: "RuntimeError",
             message: "Invalid object reference",
             pc: e2.pc,
             opcode: t2.op
           };
-        s2 = p3.data;
-      } else if (y(o2))
-        s2 = o2;
+        o2 = p2.data;
+      } else if (y(s2))
+        o2 = s2;
       else {
-        e2.stack.push(C());
+        e2.stack.push(C$1());
         return;
       }
-      const c$1 = s2.properties[p$1(r2)];
-      e2.stack.push(c$1 ?? C());
+      const c$1 = o2.properties[p$1(r2)];
+      e2.stack.push(c$1 ?? C$1());
+    }
+  },
+  [i$2.JSON_STRINGIFY]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, t2) => {
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = j(r2, e2.heap);
+      e2.stack.push(JSON.stringify(s2));
     }
   },
-  [n.JSON_STRINGIFY]: {
+  [i$2.OBJECT_KEYS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
-      if (d(r2)) return r2;
-      const o2 = j(r2, e2.heap);
-      e2.stack.push(JSON.stringify(o2));
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      if (b(r2)) {
+        const s2 = e2.heap.get(r2.id);
+        if (s2 && s2.type === "object") {
+          const o2 = s2.data, c2 = Object.keys(o2.properties), p2 = e2.heap.allocate("array", { type: "array", elements: c2 });
+          e2.stack.push(p2);
+        } else
+          e2.stack.push(null);
+      } else if (y(r2)) {
+        const s2 = Object.keys(r2.properties), o2 = e2.heap.allocate("array", { type: "array", elements: s2 });
+        e2.stack.push(o2);
+      } else
+        e2.stack.push(null);
     }
   }
-}, pe = {
-  [n.GET]: {
+}, de = {
+  [i$2.OBJECT_ITER_START]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2, t2) => {
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      if (b(r2)) {
+        const s2 = e2.heap.get(r2.id);
+        if (s2 && s2.type === "object") {
+          const o2 = s2.data, c2 = Object.keys(o2.properties);
+          e2.iterators.push({
+            array: null,
+            keys: c2,
+            index: 0,
+            length: c2.length
+          });
+        } else
+          e2.iterators.push({
+            array: null,
+            keys: [],
+            index: 0,
+            length: 0
+          });
+      } else if (y(r2)) {
+        const s2 = Object.keys(r2.properties);
+        e2.iterators.push({
+          array: null,
+          keys: s2,
+          index: 0,
+          length: s2.length
+        });
+      } else
+        e2.iterators.push({
+          array: null,
+          keys: [],
+          index: 0,
+          length: 0
+        });
+    }
+  },
+  [i$2.OBJECT_ITER_NEXT]: {
+    stackIn: 0,
+    stackOut: 2,
+    // Push key and hasNext
+    execute: (e2, t2) => {
+      const r2 = e2.iterators[e2.iterators.length - 1];
+      if (r2 && r2.index < r2.length && r2.keys) {
+        const s2 = r2.keys[r2.index];
+        e2.stack.push(s2), e2.stack.push(true), r2.index++;
+      } else
+        e2.stack.push(null), e2.stack.push(false);
+    }
+  }
+}, fe = {
+  [i$2.GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      var s2;
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (u$1(o2)) {
-        const c2 = e2.heap.get(o2.id);
+      var o2;
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (u$1(s2)) {
+        const c2 = e2.heap.get(s2.id);
         if (!c2 || c2.type !== "array")
           return {
             type: "RuntimeError",
@@ -2214,17 +2712,17 @@ const ne = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const p3 = c2.data;
-        let u2;
+        const p2 = c2.data;
+        let a2;
         if (i$1(r2))
-          u2 = r2;
+          a2 = r2;
         else if (t(r2)) {
-          const i2 = parseInt(r2, 10);
-          if (!isNaN(i2) && i2.toString() === r2 && i2 >= 0)
-            u2 = i2;
+          const u2 = parseInt(r2, 10);
+          if (!isNaN(u2) && u2.toString() === r2 && u2 >= 0)
+            a2 = u2;
           else {
-            const E2 = ((s2 = p3.properties) == null ? void 0 : s2[r2]) ?? C();
-            e2.stack.push(E2);
+            const y2 = ((o2 = p2.properties) == null ? void 0 : o2[r2]) ?? C$1();
+            e2.stack.push(y2);
             return;
           }
         } else
@@ -2234,11 +2732,11 @@ const ne = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const a2 = p3.elements[u2] ?? C();
-        e2.stack.push(a2);
+        const i2 = p2.elements[a2] ?? C$1();
+        e2.stack.push(i2);
         return;
-      } else if (b(o2)) {
-        const c2 = e2.heap.get(o2.id);
+      } else if (b(s2)) {
+        const c2 = e2.heap.get(s2.id);
         if (!c2 || c2.type !== "object")
           return {
             type: "RuntimeError",
@@ -2246,18 +2744,18 @@ const ne = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const p3 = c2.data, u2 = p$1(r2), a2 = p3.properties[u2] ?? C();
-        e2.stack.push(a2);
+        const p2 = c2.data, a2 = p$1(r2), i2 = p2.properties[a2] ?? C$1();
+        e2.stack.push(i2);
         return;
-      } else if (t(o2)) {
+      } else if (t(s2)) {
         let c2;
         if (i$1(r2))
           c2 = r2;
         else if (t(r2)) {
-          const p3 = parseInt(r2, 10);
-          !isNaN(p3) && p3.toString() === r2 && (c2 = p3);
+          const p2 = parseInt(r2, 10);
+          !isNaN(p2) && p2.toString() === r2 && (c2 = p2);
         }
-        c2 !== void 0 && c2 >= 0 && c2 < o2.length ? e2.stack.push(o2[c2]) : e2.stack.push(C());
+        c2 !== void 0 && c2 >= 0 && c2 < s2.length ? e2.stack.push(s2[c2]) : e2.stack.push(C$1());
         return;
       } else
         return {
@@ -2268,13 +2766,13 @@ const ne = {
         };
     }
   },
-  [n.SET]: {
+  [i$2.SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (u$1(s2)) {
-        const c2 = e2.heap.get(s2.id);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (u$1(o2)) {
+        const c2 = e2.heap.get(o2.id);
         if (!c2 || c2.type !== "array")
           return {
             type: "RuntimeError",
@@ -2282,16 +2780,16 @@ const ne = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const p3 = c2.data;
-        let u2;
-        if (i$1(o2))
-          u2 = o2;
-        else if (t(o2)) {
-          const i2 = parseInt(o2, 10);
-          if (!isNaN(i2) && i2.toString() === o2 && i2 >= 0)
-            u2 = i2;
+        const p2 = c2.data;
+        let a2;
+        if (i$1(s2))
+          a2 = s2;
+        else if (t(s2)) {
+          const u2 = parseInt(s2, 10);
+          if (!isNaN(u2) && u2.toString() === s2 && u2 >= 0)
+            a2 = u2;
           else {
-            p3.properties || (p3.properties = {}), p3.properties[o2] = r2, e2.stack.push(s2);
+            p2.properties || (p2.properties = {}), p2.properties[s2] = r2, e2.stack.push(o2);
             return;
           }
         } else
@@ -2301,18 +2799,18 @@ const ne = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const a2 = Math.floor(u2);
-        if (a2 < 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
           };
-        p3.elements[a2] = r2, e2.stack.push(s2);
+        p2.elements[i2] = r2, e2.stack.push(o2);
         return;
-      } else if (b(s2)) {
-        const c2 = e2.heap.get(s2.id);
+      } else if (b(o2)) {
+        const c2 = e2.heap.get(o2.id);
         if (!c2 || c2.type !== "object")
           return {
             type: "RuntimeError",
@@ -2320,8 +2818,8 @@ const ne = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const p3 = c2.data, u2 = p$1(o2);
-        p3.properties[u2] = r2, e2.stack.push(s2);
+        const p2 = c2.data, a2 = p$1(s2);
+        p2.properties[a2] = r2, e2.stack.push(o2);
         return;
       } else
         return {
@@ -2332,40 +2830,80 @@ const ne = {
         };
     }
   }
+}, ke = {
+  stackIn: 0,
+  // Consumes no stack items
+  stackOut: 1,
+  // Produces one stack item (heap reference)
+  execute: (e2, t2) => {
+    const r2 = t2.arg;
+    if (!r2 || typeof r2.pattern != "string" || typeof r2.flags != "string")
+      return {
+        type: "TypeError",
+        message: "LOAD_REGEX instruction requires pattern and flags properties",
+        pc: e2.pc,
+        opcode: t2.op
+      };
+    try {
+      const s2 = new RegExp(r2.pattern, r2.flags), o2 = {
+        type: "object",
+        properties: {
+          source: s2.source,
+          flags: s2.flags,
+          global: s2.global,
+          ignoreCase: s2.ignoreCase,
+          multiline: s2.multiline
+        }
+      }, c2 = e2.heap.allocate("object", o2);
+      e2.stack.push(c2);
+      return;
+    } catch (s2) {
+      return {
+        type: "SyntaxError",
+        message: `Invalid regular expression: ${s2.message}`,
+        pc: e2.pc,
+        opcode: t2.op
+      };
+    }
+  }
+}, me = {
+  [i$2.LOAD_REGEX]: ke
 }, F = {
-  ...B,
-  ...W,
-  ...X,
-  ...K,
-  ...Q,
   ...Z,
   ...ee,
   ...re,
   ...te,
-  ...oe,
   ...se,
+  ...oe,
   ...ce,
   ...ne,
-  ...pe
+  ...pe,
+  ...ae,
+  ...ie,
+  ...ue,
+  ...le,
+  ...de,
+  ...fe,
+  ...me
 };
-function P() {
+function w() {
   const e2 = /* @__PURE__ */ new Map();
   let t2 = 1;
   return {
     objects: e2,
     nextId: t2,
-    allocate(r2, o2) {
-      const s2 = t2++, c2 = { id: s2, type: r2, data: o2 };
-      return e2.set(s2, c2), r2 === "array" ? { type: "array-ref", id: s2 } : { type: "object-ref", id: s2 };
+    allocate(r2, s2) {
+      const o2 = t2++, c2 = { id: o2, type: r2, data: s2 };
+      return e2.set(o2, c2), r2 === "array" ? { type: "array-ref", id: o2 } : { type: "object-ref", id: o2 };
     },
     get(r2) {
-      const o2 = e2.get(r2);
-      if (o2)
-        return o2;
+      const s2 = e2.get(r2);
+      if (s2)
+        return s2;
     }
   };
 }
-class A {
+class C {
   createInitialState() {
     return {
       pc: 0,
@@ -2374,74 +2912,74 @@ class A {
       status: "running",
       output: [],
       iterators: [],
-      heap: P()
+      heap: w()
     };
   }
   executeInstruction(t2, r2) {
-    const o2 = F[r2.op];
-    if (!o2)
+    const s2 = F[r2.op];
+    if (!s2)
       throw new Error(`Unknown opcode: ${r2.op}`);
-    const s2 = this.validateStack(o2, r2, t2);
-    if (s2) {
-      t2.status = "error", t2.error = s2.message;
+    const o2 = this.validateStack(s2, r2, t2);
+    if (o2) {
+      t2.status = "error", t2.error = o2.message;
       return;
     }
-    o2.execute(t2, r2), t2.pc++;
+    s2.execute(t2, r2), t2.pc++;
   }
-  validateStack(t2, r2, o2) {
-    if (o2.stack.length < t2.stackIn)
+  validateStack(t2, r2, s2) {
+    if (s2.stack.length < t2.stackIn)
       return {
         type: "StackUnderflow",
-        message: `${n[r2.op]}: Stack underflow`,
-        pc: o2.pc,
+        message: `${i$2[r2.op]}: Stack underflow`,
+        pc: s2.pc,
         opcode: r2.op
       };
   }
-  execute(t2, r2, o2) {
-    const s2 = {
+  execute(t2, r2, s2) {
+    const o2 = {
       pc: (r2 == null ? void 0 : r2.pc) ?? 0,
       stack: (r2 == null ? void 0 : r2.stack) ?? [],
       variables: (r2 == null ? void 0 : r2.variables) ?? /* @__PURE__ */ new Map(),
       status: "running",
       output: (r2 == null ? void 0 : r2.output) ?? [],
       iterators: (r2 == null ? void 0 : r2.iterators) ?? [],
-      fileSystem: o2,
-      heap: (r2 == null ? void 0 : r2.heap) ?? P(),
+      fileSystem: s2,
+      heap: (r2 == null ? void 0 : r2.heap) ?? w(),
       ...r2
     };
-    for (; s2.status === "running" && s2.pc < t2.length; ) {
-      const c2 = t2[s2.pc], p3 = F[c2.op];
-      if (p3) {
-        const u2 = this.validateStack(p3, c2, s2);
-        if (u2) {
-          s2.status = "error", s2.error = u2.message;
+    for (; o2.status === "running" && o2.pc < t2.length; ) {
+      const c2 = t2[o2.pc], p2 = F[c2.op];
+      if (p2) {
+        const a2 = this.validateStack(p2, c2, o2);
+        if (a2) {
+          o2.status = "error", o2.error = a2.message;
           break;
         }
-        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 === 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 ${i2} target: ${c2.arg}`;
+        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) {
+          o2.status = "error";
+          const u2 = 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";
+          o2.error = `Invalid ${u2} target: ${c2.arg}`;
           break;
         }
-        const a2 = p3.execute(s2, c2);
-        if (a2) {
-          const i2 = s2.pc + 1;
-          if (i2 < t2.length && t2[i2].op === n.CC) {
-            s2.ccPrompt = `ERROR: ${a2.message}. How should I proceed?`, s2.status = "waiting_cc", s2.pc = i2;
+        const i2 = p2.execute(o2, c2);
+        if (i2) {
+          const u2 = o2.pc + 1;
+          if (u2 < t2.length && t2[u2].op === i$2.CC) {
+            o2.ccPrompt = `ERROR: ${i2.message}. How should I proceed?`, o2.status = "waiting_cc", o2.pc = u2;
             break;
           }
-          s2.status = "error", s2.error = a2.message;
+          o2.status = "error", o2.error = i2.message;
           break;
         }
-        p3.controlsPC || s2.pc++;
+        p2.controlsPC || o2.pc++;
         continue;
       }
-      s2.status = "error", s2.error = `Unknown opcode: ${n[c2.op]}`;
+      o2.status = "error", o2.error = `Unknown opcode: ${i$2[c2.op]}`;
       break;
     }
-    return s2;
+    return o2;
   }
-  resume(t2, r2, o2, s2) {
+  resume(t2, r2, s2, o2) {
     if (t2.status !== "waiting_cc")
       throw new Error("Cannot resume: VM not waiting for CC");
     const c2 = {
@@ -2451,47 +2989,47 @@ class A {
       ccPrompt: void 0,
       pc: t2.pc + 1
     };
-    return this.execute(o2, c2, s2 || t2.fileSystem);
+    return this.execute(s2, c2, o2 || t2.fileSystem);
   }
 }
-class G {
+class V {
   constructor() {
     _(this, "sandboxPaths", []);
     const t2 = process.env.CVM_SANDBOX_PATHS, r2 = process.env.CVM_SANDBOX_ROOT;
-    t2 ? this.sandboxPaths = t2.split(",").map((o2) => r__namespace.resolve(o2.trim())) : r2 && (this.sandboxPaths = [r__namespace.resolve(r2)]);
+    t2 ? this.sandboxPaths = t2.split(",").map((s2) => r__namespace.resolve(s2.trim())) : r2 && (this.sandboxPaths = [r__namespace.resolve(r2)]);
   }
   isPathAllowed(t2) {
     const r2 = r__namespace.resolve(t2);
     return r2.includes("..") || this.sandboxPaths.length === 0 ? false : this.sandboxPaths.some(
-      (o2) => r2.startsWith(o2)
+      (s2) => r2.startsWith(s2)
     );
   }
   listFiles(t2, r2 = {}) {
-    const o2 = s();
+    const s$12 = s();
     if (!this.isPathAllowed(t2))
-      return o2;
+      return s$12;
     try {
-      const s2 = r__namespace.resolve(t2);
-      this.listFilesRecursive(s2, s2, o2.elements, r2);
+      const o2 = r__namespace.resolve(t2);
+      this.listFilesRecursive(o2, o2, s$12.elements, r2);
     } catch {
     }
-    return o2;
+    return s$12;
   }
   matchesPattern(t2, r2) {
-    let o2 = r2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
-    o2 = "^" + o2 + "$";
+    let s2 = r2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
+    s2 = "^" + s2 + "$";
     try {
-      return new RegExp(o2).test(t2);
+      return new RegExp(s2).test(t2);
     } catch {
       return true;
     }
   }
-  listFilesRecursive(t2, r2, o2, s2, c2 = 0) {
+  listFilesRecursive(t2, r2, s2, o2, c2 = 0) {
     try {
-      const p3 = b__namespace.readdirSync(r2, { withFileTypes: true });
-      for (const u2 of p3) {
-        const a2 = r__namespace.join(r2, u2.name), i2 = r__namespace.relative(t2, a2);
-        u2.isSymbolicLink() || s2.filter && !this.matchesPattern(i2, s2.filter) || (o2.push(a2), u2.isDirectory() && s2.recursive && this.listFilesRecursive(t2, a2, o2, s2, c2 + 1));
+      const p2 = N__namespace.readdirSync(r2, { withFileTypes: true });
+      for (const a2 of p2) {
+        const i2 = r__namespace.join(r2, a2.name), u2 = r__namespace.relative(t2, i2);
+        a2.isSymbolicLink() || o2.filter && !this.matchesPattern(u2, o2.filter) || (s2.push(i2), a2.isDirectory() && o2.recursive && this.listFilesRecursive(t2, i2, s2, o2, c2 + 1));
       }
     } catch {
     }
@@ -2500,8 +3038,8 @@ class G {
     if (!this.isPathAllowed(t2))
       return null;
     try {
-      const r2 = r__namespace.resolve(t2), o2 = b__namespace.lstatSync(r2);
-      return o2.isSymbolicLink() || !o2.isFile() ? null : b__namespace.readFileSync(r2, "utf-8");
+      const r2 = r__namespace.resolve(t2), s2 = N__namespace.lstatSync(r2);
+      return s2.isSymbolicLink() || !s2.isFile() ? null : N__namespace.readFileSync(r2, "utf-8");
     } catch {
       return null;
     }
@@ -2510,29 +3048,29 @@ class G {
     if (!this.isPathAllowed(t2))
       return false;
     try {
-      const o2 = r__namespace.resolve(t2), s2 = r__namespace.dirname(o2);
-      if (!this.isPathAllowed(s2))
+      const s2 = r__namespace.resolve(t2), o2 = r__namespace.dirname(s2);
+      if (!this.isPathAllowed(o2))
         return false;
       try {
-        if (b__namespace.lstatSync(o2).isSymbolicLink())
+        if (N__namespace.lstatSync(s2).isSymbolicLink())
           return false;
       } catch (c2) {
         if (c2.code !== "ENOENT")
           return false;
       }
-      return b__namespace.mkdirSync(s2, { recursive: true }), b__namespace.writeFileSync(o2, r2, "utf-8"), true;
+      return N__namespace.mkdirSync(o2, { recursive: true }), N__namespace.writeFileSync(s2, r2, "utf-8"), true;
     } catch {
       return false;
     }
   }
 }
-new G();
-class fe {
+new V();
+class Ie {
   constructor(t2, r2) {
     _(this, "vms", /* @__PURE__ */ new Map());
     _(this, "storage");
     _(this, "fileSystem");
-    t2 ? this.storage = t2 : this.storage = E.create(), this.fileSystem = r2 || new G();
+    t2 ? this.storage = t2 : this.storage = E.create(), this.fileSystem = r2 || new V();
   }
   /**
    * Initialize the VMManager (connect to database)
@@ -2550,18 +3088,18 @@ class fe {
    * Load and compile a program from source code
    */
   async loadProgram(t2, r2) {
-    const o2 = j$2(r2);
-    if (!o2.success)
-      throw new Error(`Compilation failed: ${o2.errors.join(", ")}`);
-    const s2 = {
+    const s2 = te$1(r2);
+    if (!s2.success)
+      throw new Error(`Compilation failed: ${s2.errors.join(", ")}`);
+    const o2 = {
       id: t2,
       name: t2,
       source: r2,
-      bytecode: o2.bytecode,
+      bytecode: s2.bytecode,
       // VM decides internal format
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveProgram(s2);
+    await this.storage.saveProgram(o2);
   }
   /**
    * Start execution of a loaded program
@@ -2569,7 +3107,7 @@ class fe {
   async startExecution(t2, r2) {
     if (!await this.storage.getProgram(t2))
       throw new Error(`Program not found: ${t2}`);
-    const s2 = {
+    const o2 = {
       id: r2,
       programId: t2,
       state: "READY",
@@ -2578,8 +3116,8 @@ class fe {
       variables: {},
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveExecution(s2);
-    const c2 = new A();
+    await this.storage.saveExecution(o2);
+    const c2 = new C();
     this.vms.set(r2, c2);
   }
   /**
@@ -2591,34 +3129,34 @@ class fe {
     if (!r2)
       throw new Error(`Execution not found: ${t2}`);
     if (r2.state === "READY" || r2.state === "RUNNING") {
-      const o2 = await this.storage.getProgram(r2.programId);
-      if (!o2)
+      const s2 = await this.storage.getProgram(r2.programId);
+      if (!s2)
         throw new Error(`Program not found: ${r2.programId}`);
-      let s2 = this.vms.get(t2);
-      s2 || (s2 = new A(), this.vms.set(t2, s2));
+      let o2 = this.vms.get(t2);
+      o2 || (o2 = new C(), this.vms.set(t2, o2));
       const c2 = r2.state === "READY" ? {
         pc: 0,
         stack: [],
         variables: /* @__PURE__ */ new Map(),
         output: []
-      } : this.deserializeVMState(r2), p3 = s2.execute(o2.bytecode, c2, this.fileSystem);
-      p3.output.length > 0 && await this.storage.appendOutput(t2, p3.output);
-      const u2 = this.serializeVMState(p3);
-      if (Object.assign(r2, u2), p3.status === "complete")
-        return r2.state = "COMPLETED", p3.returnValue !== void 0 && (r2.returnValue = p3.returnValue), await this.storage.saveExecution(r2), this.vms.delete(t2), {
+      } : this.deserializeVMState(r2), p2 = o2.execute(s2.bytecode, c2, this.fileSystem);
+      p2.output.length > 0 && await this.storage.appendOutput(t2, p2.output);
+      const a2 = this.serializeVMState(p2);
+      if (Object.assign(r2, a2), p2.status === "complete")
+        return r2.state = "COMPLETED", p2.returnValue !== void 0 && (r2.returnValue = p2.returnValue), await this.storage.saveExecution(r2), this.vms.delete(t2), {
           type: "completed",
           message: "Execution completed",
-          result: p3.returnValue
+          result: p2.returnValue
         };
-      if (p3.status === "waiting_cc")
-        return r2.state = "AWAITING_COGNITIVE_RESULT", r2.ccPrompt = p3.ccPrompt, await this.storage.saveExecution(r2), {
+      if (p2.status === "waiting_cc")
+        return r2.state = "AWAITING_COGNITIVE_RESULT", r2.ccPrompt = p2.ccPrompt, await this.storage.saveExecution(r2), {
           type: "waiting",
-          message: p3.ccPrompt || "Waiting for input"
+          message: p2.ccPrompt || "Waiting for input"
         };
-      if (p3.status === "error")
-        return r2.state = "ERROR", r2.error = p3.error, await this.storage.saveExecution(r2), this.vms.delete(t2), {
+      if (p2.status === "error")
+        return r2.state = "ERROR", r2.error = p2.error, await this.storage.saveExecution(r2), this.vms.delete(t2), {
           type: "error",
-          error: p3.error
+          error: p2.error
         };
     }
     if (r2.state === "COMPLETED")
@@ -2642,24 +3180,24 @@ class fe {
    * Report result from cognitive operation and continue execution
    */
   async reportCCResult(t2, r2) {
-    const o2 = await this.storage.getExecution(t2);
-    if (!o2)
-      throw new Error(`Execution not found: ${t2}`);
-    const s2 = await this.storage.getProgram(o2.programId);
+    const s2 = await this.storage.getExecution(t2);
     if (!s2)
-      throw new Error(`Program not found: ${o2.programId}`);
+      throw new Error(`Execution not found: ${t2}`);
+    const o2 = await this.storage.getProgram(s2.programId);
+    if (!o2)
+      throw new Error(`Program not found: ${s2.programId}`);
     let c2 = this.vms.get(t2);
-    c2 || (c2 = new A(), this.vms.set(t2, c2));
-    const p3 = {
-      ...this.deserializeVMState(o2),
+    c2 || (c2 = new C(), this.vms.set(t2, c2));
+    const p2 = {
+      ...this.deserializeVMState(s2),
       status: "waiting_cc",
       output: [],
       // Start with empty output for resumed execution
       ccPrompt: void 0
-    }, u2 = c2.resume(p3, r2, s2.bytecode, this.fileSystem);
-    u2.output.length > 0 && await this.storage.appendOutput(t2, u2.output);
-    const a2 = this.serializeVMState(u2);
-    Object.assign(o2, a2), u2.status === "complete" ? (o2.state = "COMPLETED", u2.returnValue !== void 0 && (o2.returnValue = u2.returnValue), this.vms.delete(t2)) : u2.status === "error" ? (o2.state = "ERROR", o2.error = u2.error, this.vms.delete(t2)) : u2.status === "waiting_cc" ? (o2.state = "AWAITING_COGNITIVE_RESULT", o2.ccPrompt = u2.ccPrompt) : o2.state = "RUNNING", await this.storage.saveExecution(o2);
+    }, a2 = c2.resume(p2, r2, o2.bytecode, this.fileSystem);
+    a2.output.length > 0 && await this.storage.appendOutput(t2, a2.output);
+    const i2 = this.serializeVMState(a2);
+    Object.assign(s2, i2), a2.status === "complete" ? (s2.state = "COMPLETED", a2.returnValue !== void 0 && (s2.returnValue = a2.returnValue), this.vms.delete(t2)) : a2.status === "error" ? (s2.state = "ERROR", s2.error = a2.error, this.vms.delete(t2)) : a2.status === "waiting_cc" ? (s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = a2.ccPrompt) : s2.state = "RUNNING", await this.storage.saveExecution(s2);
   }
   /**
    * Get current execution status
@@ -2731,22 +3269,22 @@ class fe {
    * Restart a program (create new execution and set as current)
    */
   async restartExecution(t2, r2) {
-    const o2 = r2 || `${t2}-${Date.now()}`;
-    return await this.startExecution(t2, o2), await this.setCurrentExecutionId(o2), o2;
+    const s2 = r2 || `${t2}-${Date.now()}`;
+    return await this.startExecution(t2, s2), await this.setCurrentExecutionId(s2), s2;
   }
   /**
    * Serialize heap to storage format
    */
   serializeHeap(t2) {
-    const r2 = (s2, c2) => u$1(c2) || b(c2) ? { $ref: c2.id } : c2, o2 = {};
-    return t2.objects.forEach((s2, c2) => {
-      o2[c2] = {
-        type: s2.type,
+    const r2 = (o2, c2) => u$1(c2) || b(c2) ? { $ref: c2.id } : c2, s2 = {};
+    return t2.objects.forEach((o2, c2) => {
+      s2[c2] = {
+        type: o2.type,
         // Serialize each object's data individually with replacer
-        data: JSON.parse(JSON.stringify(s2.data, r2))
+        data: JSON.parse(JSON.stringify(o2.data, r2))
       };
     }), {
-      objects: o2,
+      objects: s2,
       nextId: t2.nextId
     };
   }
@@ -2754,19 +3292,19 @@ class fe {
    * Deserialize heap from storage format
    */
   deserializeHeap(t2) {
-    const r2 = P();
+    const r2 = w();
     r2.nextId = t2.nextId;
-    for (const o2 in t2.objects) {
-      const s2 = parseInt(o2, 10), c2 = t2.objects[s2];
-      r2.objects.set(s2, {
-        id: s2,
+    for (const s2 in t2.objects) {
+      const o2 = parseInt(s2, 10), c2 = t2.objects[o2];
+      r2.objects.set(o2, {
+        id: o2,
         type: c2.type,
         data: c2.data
         // Still contains $ref stubs
       });
     }
-    return r2.objects.forEach((o2) => {
-      o2.data = this.restoreReferences(o2.data, r2);
+    return r2.objects.forEach((s2) => {
+      s2.data = this.restoreReferences(s2.data, r2);
     }), r2;
   }
   /**
@@ -2794,7 +3332,7 @@ class fe {
       pc: t2.pc || 0,
       stack: t2.stack || [],
       variables: new Map(Object.entries(t2.variables || {})),
-      heap: t2.heap ? this.deserializeHeap(t2.heap) : P(),
+      heap: t2.heap ? this.deserializeHeap(t2.heap) : w(),
       iterators: t2.iterators || [],
       status: t2.status || "running",
       error: t2.error || null,
@@ -2805,16 +3343,16 @@ class fe {
   }
   restoreReferences(t2, r2) {
     if (t2 && typeof t2 == "object" && t2.$ref !== void 0) {
-      const o2 = r2.objects.get(t2.$ref);
-      return (o2 == null ? void 0 : o2.type) === "array" ? { type: "array-ref", id: t2.$ref } : (o2 == null ? void 0 : o2.type) === "object" ? { type: "object-ref", id: t2.$ref } : t2;
+      const s2 = r2.objects.get(t2.$ref);
+      return (s2 == null ? void 0 : s2.type) === "array" ? { type: "array-ref", id: t2.$ref } : (s2 == null ? void 0 : s2.type) === "object" ? { type: "object-ref", id: t2.$ref } : t2;
     }
     if (Array.isArray(t2))
-      return t2.map((o2) => this.restoreReferences(o2, r2));
+      return t2.map((s2) => this.restoreReferences(s2, r2));
     if (t2 && typeof t2 == "object") {
-      const o2 = {};
-      for (const s2 in t2)
-        o2[s2] = this.restoreReferences(t2[s2], r2);
-      return o2;
+      const s2 = {};
+      for (const o2 in t2)
+        s2[o2] = this.restoreReferences(t2[o2], r2);
+      return s2;
     }
     return t2;
   }
@@ -2828,7 +3366,7 @@ class $ {
     i(this, "transport", null);
     i(this, "vmManager");
     i(this, "version");
-    this.version = e2, this.vmManager = new fe(), this.server = new mcp_js.McpServer({
+    this.version = e2, this.vmManager = new Ie(), this.server = new mcp_js.McpServer({
       name: "cvm-server",
       version: this.version
     }), this.setupTools();
@@ -2866,19 +3404,19 @@ class $ {
       },
       async ({ programId: e2, filePath: r$1 }) => {
         try {
-          const t2 = r.resolve(r$1), n2 = await promises.readFile(t2, "utf-8");
-          return await this.vmManager.loadProgram(e2, n2), {
+          const t2 = r.resolve(r$1), n = await promises.readFile(t2, "utf-8");
+          return await this.vmManager.loadProgram(e2, n), {
             content: [{ type: "text", text: `Program loaded successfully from ${r$1}: ${e2}` }]
           };
         } catch (t2) {
           if (t2 instanceof Error) {
-            const n2 = t2;
-            if (n2.code === "ENOENT")
+            const n = t2;
+            if (n.code === "ENOENT")
               return {
                 content: [{ type: "text", text: `Error: File not found: ${r$1}` }],
                 isError: true
               };
-            if (n2.code === "EACCES")
+            if (n.code === "EACCES")
               return {
                 content: [{ type: "text", text: `Error: Permission denied: ${r$1}` }],
                 isError: true
@@ -2902,9 +3440,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 (n2) {
+        } catch (n) {
           return {
-            content: [{ type: "text", text: `Error: ${n2 instanceof Error ? n2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${n instanceof Error ? n.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -2918,12 +3456,12 @@ class $ {
         try {
           let r2 = e2;
           if (!r2) {
-            const n2 = await this.vmManager.getCurrentExecutionId();
-            if (!n2)
+            const n = await this.vmManager.getCurrentExecutionId();
+            if (!n)
               return {
                 content: [{ type: "text", text: "No current execution set. Use list_executions to see available executions." }]
               };
-            r2 = n2;
+            r2 = n;
           }
           const t2 = await this.vmManager.getNext(r2);
           return t2.type === "completed" ? {
@@ -2954,13 +3492,13 @@ class $ {
         try {
           let t2 = e2;
           if (!t2) {
-            const n2 = await this.vmManager.getCurrentExecutionId();
-            if (!n2)
+            const n = await this.vmManager.getCurrentExecutionId();
+            if (!n)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            t2 = n2;
+            t2 = n;
           }
           return await this.vmManager.reportCCResult(t2, r2), {
             content: [{ type: "text", text: "Execution resumed" }]
@@ -2981,13 +3519,13 @@ class $ {
         try {
           let r2 = e2;
           if (!r2) {
-            const n2 = await this.vmManager.getCurrentExecutionId();
-            if (!n2)
+            const n = await this.vmManager.getCurrentExecutionId();
+            if (!n)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            r2 = n2;
+            r2 = n;
           }
           const t2 = await this.vmManager.getExecutionStatus(r2);
           return {
@@ -3005,14 +3543,14 @@ class $ {
       {},
       async () => {
         try {
-          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,
+          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,
             summary: {
-              currentPrompt: n2.state === "AWAITING_COGNITIVE_RESULT" ? n2.ccPrompt : void 0,
+              currentPrompt: n.state === "AWAITING_COGNITIVE_RESULT" ? n.ccPrompt : void 0,
               tasksCompleted: 0
               // TODO: Track this in future
             }
@@ -3044,12 +3582,12 @@ class $ {
               };
             r2 = a2;
           }
-          const t2 = await this.vmManager.getExecutionWithAttempts(r2), n2 = await this.vmManager.getCurrentExecutionId(), c2 = {
+          const t2 = await this.vmManager.getExecutionWithAttempts(r2), n = await this.vmManager.getCurrentExecutionId(), c2 = {
             executionId: t2.id,
             programId: t2.programId,
             state: t2.state,
             created: t2.created,
-            isCurrent: t2.id === n2,
+            isCurrent: t2.id === n,
             currentTask: t2.state === "AWAITING_COGNITIVE_RESULT" ? {
               prompt: t2.ccPrompt,
               attempts: t2.attempts || 1,
@@ -3306,7 +3844,7 @@ async function main() {
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        const packageJson = JSON.parse(b$2.readFileSync(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse(N$1.readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.name === "cvm-server" && packageJson.version) {
           version = packageJson.version;
           break;