@probelabs/probe 0.6.0-rc233 → 0.6.0-rc235

package/cjs/index.cjs

@@ -35678,7 +35678,7 @@ Manage tasks for tracking progress during code exploration and problem-solving.
 
 Parameters:
 - action: (required) The action to perform: create, update, complete, delete, list
-- tasks: (optional) JSON array for batch operations - alternative to single-task params
+- tasks: (optional) Array of task objects for batch operations. Place raw JSON array directly between tags.
 - id: (optional) Task ID for single operations (e.g., "task-1")
 - title: (optional) Task title for create/update
 - description: (optional) Task description for create/update
@@ -35687,6 +35687,11 @@ Parameters:
 - dependencies: (optional) JSON array of task IDs that must be completed first
 - after: (optional) Task ID to insert the new task after (for ordering). By default, new tasks are appended to the end
 
+IMPORTANT - JSON Format:
+Place raw JSON arrays directly between tags without quotes or escaping:
+  CORRECT:   <tasks>[{"title": "Do X"}]</tasks>
+  INCORRECT: <tasks>"[{"title": "Do X"}]"</tasks>
+
 Usage Examples:
 
 Creating a single task:
@@ -81050,9 +81055,11 @@ __export(schemaUtils_exports, {
   isJsonSchema: () => isJsonSchema,
   isJsonSchemaDefinition: () => isJsonSchemaDefinition,
   isMermaidSchema: () => isMermaidSchema,
+  isSimpleTextWrapperSchema: () => isSimpleTextWrapperSchema,
   processSchemaResponse: () => processSchemaResponse,
   replaceMermaidDiagramsInJson: () => replaceMermaidDiagramsInJson,
   replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  tryAutoWrapForSimpleSchema: () => tryAutoWrapForSimpleSchema,
   tryMaidAutoFix: () => tryMaidAutoFix,
   validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
   validateJsonResponse: () => validateJsonResponse,
@@ -81570,6 +81577,46 @@ function isJsonSchemaDefinition(jsonString, options = {}) {
     return false;
   }
 }
+function isSimpleTextWrapperSchema(schema) {
+  if (!schema || typeof schema !== "string") {
+    return null;
+  }
+  const trimmed = schema.trim();
+  const simplePatterns = [
+    /^\{\s*["']?(\w+)["']?\s*:\s*["']?string["']?\s*\}$/i,
+    /^\{\s*["']?type["']?\s*:\s*["']?object["']?\s*,\s*["']?properties["']?\s*:\s*\{\s*["']?(\w+)["']?\s*:\s*\{\s*["']?type["']?\s*:\s*["']?string["']?\s*\}\s*\}\s*\}$/i
+  ];
+  for (const pattern of simplePatterns) {
+    const match2 = trimmed.match(pattern);
+    if (match2) {
+      return { fieldName: match2[1] };
+    }
+  }
+  return null;
+}
+function tryAutoWrapForSimpleSchema(response, schema, options = {}) {
+  const { debug = false } = options;
+  const wrapperInfo = isSimpleTextWrapperSchema(schema);
+  if (!wrapperInfo) {
+    if (debug) {
+      console.log(`[DEBUG] Auto-wrap: Schema is not a simple text wrapper`);
+    }
+    return null;
+  }
+  try {
+    JSON.parse(response);
+    if (debug) {
+      console.log(`[DEBUG] Auto-wrap: Response is already valid JSON, skipping`);
+    }
+    return null;
+  } catch {
+  }
+  const wrapped = JSON.stringify({ [wrapperInfo.fieldName]: response });
+  if (debug) {
+    console.log(`[DEBUG] Auto-wrap: Wrapped plain text in {"${wrapperInfo.fieldName}": ...} (${response.length} chars)`);
+  }
+  return wrapped;
+}
 function createJsonCorrectionPrompt(invalidResponse, schema, errorOrValidation, retryCount = 0) {
   let errorMessage;
   let enhancedError;
@@ -81601,7 +81648,7 @@ function createJsonCorrectionPrompt(invalidResponse, schema, errorOrValidation,
   const currentLevel = strengthLevels[level];
   let prompt = `${currentLevel.prefix} Your previous response is not valid JSON and cannot be parsed. Here's what you returned:
 
-${invalidResponse.substring(0, 500)}${invalidResponse.length > 500 ? "..." : ""}
+${invalidResponse}
 
 Error: ${enhancedError}
 
@@ -96638,6 +96685,14 @@ ${errorXml}
                     });
                     const executeToolCall = async () => {
                       if (toolName === "delegate") {
+                        let allowedToolsForDelegate = null;
+                        if (this.allowedTools.mode === "whitelist") {
+                          allowedToolsForDelegate = [...this.allowedTools.allowed];
+                        } else if (this.allowedTools.mode === "none") {
+                          allowedToolsForDelegate = [];
+                        } else if (this.allowedTools.mode === "all" && this.allowedTools.exclusions?.length > 0) {
+                          allowedToolsForDelegate = ["*", ...this.allowedTools.exclusions.map((t4) => "!" + t4)];
+                        }
                         const enhancedParams = {
                           ...toolParams,
                           currentIteration,
@@ -96653,6 +96708,18 @@ ${errorXml}
                           searchDelegate: this.searchDelegate,
                           enableTasks: this.enableTasks,
                           // Inherit task management (subagent gets isolated TaskManager)
+                          enableMcp: !!this.mcpBridge,
+                          // Inherit MCP enablement
+                          mcpConfig: this.mcpConfig,
+                          // Inherit MCP configuration
+                          mcpConfigPath: this.mcpConfigPath,
+                          // Inherit MCP config path
+                          enableBash: this.enableBash,
+                          // Inherit bash enablement
+                          bashConfig: this.bashConfig,
+                          // Inherit bash configuration
+                          allowedTools: allowedToolsForDelegate,
+                          // Inherit allowed tools from parent
                           debug: this.debug,
                           tracer: this.tracer
                         };
@@ -97271,6 +97338,16 @@ Convert your previous response content into actual JSON data that follows this s
                   validation = validateJsonResponse(finalResult);
                   retryCount = 1;
                 }
+                if (!validation.isValid) {
+                  const autoWrapped = tryAutoWrapForSimpleSchema(finalResult, options.schema, { debug: this.debug });
+                  if (autoWrapped) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] JSON validation: Auto-wrapped plain text for simple schema`);
+                    }
+                    finalResult = autoWrapped;
+                    validation = validateJsonResponse(finalResult, { debug: this.debug });
+                  }
+                }
                 while (!validation.isValid && retryCount < maxRetries) {
                   if (this.debug) {
                     console.log(`[DEBUG] JSON validation: attempt_completion validation failed (attempt ${retryCount + 1}/${maxRetries}):`, validation.error);
@@ -100807,6 +100884,8 @@ var require_utils2 = __commonJS({
     var AsyncGeneratorFunction = Object.getPrototypeOf(async function* () {
     }).constructor;
     var SandboxGlobal = function SandboxGlobal2(globals) {
+      if (globals === globalThis)
+        return globalThis;
       for (const i4 in globals) {
         this[i4] = globals[i4];
       }
@@ -100835,9 +100914,7 @@ var require_utils2 = __commonJS({
         prototypeWhitelist: new Map([...options.prototypeWhitelist].map((a4) => [a4[0].prototype, a4[1]])),
         options,
         globalScope: new Scope3(null, options.globals, sandboxGlobal),
-        sandboxGlobal,
-        ticks: { ticks: 0n, tickLimit: options.executionQuota },
-        sandboxedFunctions: /* @__PURE__ */ new WeakSet()
+        sandboxGlobal
       };
       context.prototypeWhitelist.set(Object.getPrototypeOf([][Symbol.iterator]()), /* @__PURE__ */ new Set());
       return context;
@@ -100852,15 +100929,9 @@ var require_utils2 = __commonJS({
         evals.set(AsyncFunction, asyncFunc);
         evals.set(GeneratorFunction, func);
         evals.set(AsyncGeneratorFunction, asyncFunc);
-        evals.set(eval, evalContext.sandboxedEval(func, execContext));
-        evals.set(setTimeout, evalContext.sandboxedSetTimeout(func, execContext));
-        evals.set(setInterval, evalContext.sandboxedSetInterval(func, execContext));
-        evals.set(clearTimeout, evalContext.sandboxedClearTimeout(execContext));
-        evals.set(clearInterval, evalContext.sandboxedClearInterval(execContext));
-        for (const [key, value] of evals) {
-          sandbox.context.prototypeWhitelist.set(value.prototype, /* @__PURE__ */ new Set());
-          sandbox.context.prototypeWhitelist.set(key.prototype, /* @__PURE__ */ new Set());
-        }
+        evals.set(eval, evalContext.sandboxedEval(func));
+        evals.set(setTimeout, evalContext.sandboxedSetTimeout(func));
+        evals.set(setInterval, evalContext.sandboxedSetInterval(func));
       }
       return execContext;
     }
@@ -100957,45 +101028,34 @@ var require_utils2 = __commonJS({
       return ret;
     }
     var reservedWords2 = /* @__PURE__ */ new Set([
-      "await",
-      "break",
-      "case",
-      "catch",
-      "class",
-      "const",
-      "continue",
-      "debugger",
-      "default",
-      "delete",
-      "do",
-      "else",
-      "enum",
-      "export",
-      "extends",
-      "false",
-      "finally",
-      "for",
-      "function",
-      "if",
-      "implements",
-      "import",
-      "in",
       "instanceof",
-      "let",
-      "new",
-      "null",
+      "typeof",
       "return",
-      "super",
-      "switch",
-      "this",
       "throw",
-      "true",
       "try",
-      "typeof",
+      "catch",
+      "if",
+      "finally",
+      "else",
+      "in",
+      "of",
       "var",
-      "void",
+      "let",
+      "const",
+      "for",
+      "delete",
+      "false",
+      "true",
       "while",
-      "with"
+      "do",
+      "break",
+      "continue",
+      "new",
+      "function",
+      "async",
+      "await",
+      "switch",
+      "case"
     ]);
     var Scope3 = class {
       constructor(parent, vars = {}, functionThis) {
@@ -101010,16 +101070,25 @@ var require_utils2 = __commonJS({
         this.globals = parent === null ? keysOnly(vars) : {};
         this.functionThis = functionThis;
       }
-      get(key) {
-        const isThis = key === "this";
-        const scope = this.getWhereValScope(key, isThis);
-        if (scope && isThis) {
-          return new Prop({ this: scope.functionThis }, key, false, false, true);
+      get(key, functionScope = false) {
+        const functionThis = this.functionThis;
+        if (key === "this" && functionThis !== void 0) {
+          return new Prop({ this: functionThis }, key, true, false, true);
         }
-        if (!scope) {
-          return new Prop(void 0, key);
+        if (reservedWords2.has(key))
+          throw new SyntaxError("Unexepected token '" + key + "'");
+        if (this.parent === null || !functionScope || functionThis !== void 0) {
+          if (this.globals.hasOwnProperty(key)) {
+            return new Prop(functionThis, key, false, true, true);
+          }
+          if (key in this.allVars && (!(key in {}) || this.allVars.hasOwnProperty(key))) {
+            return new Prop(this.allVars, key, this.const.hasOwnProperty(key), this.globals.hasOwnProperty(key), true);
+          }
+          if (this.parent === null) {
+            return new Prop(void 0, key);
+          }
         }
-        return new Prop(scope.allVars, key, key in scope.const, key in scope.globals, true);
+        return this.parent.get(key, functionScope);
       }
       set(key, val) {
         if (key === "this")
@@ -101030,72 +101099,34 @@ var require_utils2 = __commonJS({
         if (prop.context === void 0) {
           throw new ReferenceError(`Variable '${key}' was not declared.`);
         }
-        if (prop.context === null) {
-          throw new TypeError(`Cannot set properties of null, (setting '${key}')`);
-        }
         if (prop.isConst) {
           throw new TypeError(`Cannot assign to const variable '${key}'`);
         }
         if (prop.isGlobal) {
           throw new SandboxError(`Cannot override global variable '${key}'`);
         }
+        if (!(prop.context instanceof Object))
+          throw new SandboxError("Scope is not an object");
         prop.context[prop.prop] = val;
         return prop;
       }
-      getWhereValScope(key, isThis) {
-        if (isThis) {
-          if (this.functionThis !== void 0) {
-            return this;
-          } else {
-            return this.parent?.getWhereValScope(key, isThis) || null;
-          }
-        }
-        if (key in this.allVars && !(key in {} && !hasOwnProperty19(this.allVars, key))) {
-          return this;
-        }
-        return this.parent?.getWhereValScope(key, isThis) || null;
-      }
-      getWhereVarScope(key, localScope = false) {
-        if (key in this.allVars && !(key in {} && !hasOwnProperty19(this.allVars, key))) {
-          return this;
-        }
-        if (this.parent === null || localScope || this.functionThis !== void 0) {
-          return this;
-        }
-        return this.parent.getWhereVarScope(key, localScope);
-      }
       declare(key, type, value = void 0, isGlobal = false) {
         if (key === "this")
           throw new SyntaxError('"this" cannot be declared');
         if (reservedWords2.has(key))
           throw new SyntaxError("Unexepected token '" + key + "'");
-        const existingScope = this.getWhereVarScope(
-          key,
-          type !== "var"
-          /* VarType.var */
-        );
-        if (type === "var") {
-          if (existingScope.var[key]) {
-            existingScope.allVars[key] = value;
-            if (!isGlobal) {
-              delete existingScope.globals[key];
-            } else {
-              existingScope.globals[key] = true;
-            }
-            return new Prop(existingScope.allVars, key, false, existingScope.globals[key], true);
-          } else if (key in existingScope.allVars) {
-            throw new SyntaxError(`Identifier '${key}' has already been declared`);
-          }
-        }
-        if (key in existingScope.allVars) {
-          throw new SyntaxError(`Identifier '${key}' has already been declared`);
-        }
-        if (isGlobal) {
-          existingScope.globals[key] = true;
+        if (type === "var" && this.functionThis === void 0 && this.parent !== null) {
+          return this.parent.declare(key, type, value, isGlobal);
+        } else if (this[type].hasOwnProperty(key) && type !== "const" && !this.globals.hasOwnProperty(key) || !(key in this.allVars)) {
+          if (isGlobal) {
+            this.globals[key] = true;
+          }
+          this[type][key] = true;
+          this.allVars[key] = value;
+        } else {
+          throw new SandboxError(`Identifier '${key}' has already been declared`);
         }
-        existingScope[type][key] = true;
-        existingScope.allVars[key] = value;
-        return new Prop(this.allVars, key, type === "const", isGlobal, true);
+        return new Prop(this.allVars, key, this.const.hasOwnProperty(key), isGlobal);
       }
     };
     var FunctionScope = class {
@@ -101104,16 +101135,8 @@ var require_utils2 = __commonJS({
     };
     var SandboxError = class extends Error {
     };
-    var SandboxExecutionQuotaExceededError = class extends SandboxError {
-    };
-    var SandboxExecutionTreeError = class extends SandboxError {
-    };
-    var SandboxCapabilityError = class extends SandboxError {
-    };
-    var SandboxAccessError = class extends SandboxError {
-    };
     function isLisp(item) {
-      return Array.isArray(item) && typeof item[0] === "number" && item[0] !== 0 && item[0] !== 88;
+      return Array.isArray(item) && typeof item[0] === "number" && item[0] !== 0 && item[0] !== 89;
     }
     var Prop = class {
       constructor(context, prop, isConst = false, isGlobal = false, isVariable = false) {
@@ -101126,16 +101149,13 @@ var require_utils2 = __commonJS({
       get(context) {
         const ctx = this.context;
         if (ctx === void 0)
-          throw new ReferenceError(`${this.prop.toString()} is not defined`);
+          throw new ReferenceError(`${this.prop} is not defined`);
         if (ctx === null)
-          throw new TypeError(`Cannot read properties of null, (reading '${this.prop.toString()}')`);
-        context.getSubscriptions.forEach((cb) => cb(ctx, this.prop.toString()));
+          throw new TypeError(`Cannot read properties of null, (reading '${this.prop}')`);
+        context.getSubscriptions.forEach((cb) => cb(ctx, this.prop));
         return ctx[this.prop];
       }
     };
-    function hasOwnProperty19(obj, prop) {
-      return Object.prototype.hasOwnProperty.call(obj, prop);
-    }
     exports2.AsyncFunction = AsyncFunction;
     exports2.AsyncGeneratorFunction = AsyncGeneratorFunction;
     exports2.CodeString = CodeString;
@@ -101144,18 +101164,12 @@ var require_utils2 = __commonJS({
     exports2.GeneratorFunction = GeneratorFunction;
     exports2.LocalScope = LocalScope;
     exports2.Prop = Prop;
-    exports2.SandboxAccessError = SandboxAccessError;
-    exports2.SandboxCapabilityError = SandboxCapabilityError;
     exports2.SandboxError = SandboxError;
-    exports2.SandboxExecutionQuotaExceededError = SandboxExecutionQuotaExceededError;
-    exports2.SandboxExecutionTreeError = SandboxExecutionTreeError;
     exports2.SandboxGlobal = SandboxGlobal;
     exports2.Scope = Scope3;
     exports2.createContext = createContext;
     exports2.createExecContext = createExecContext;
-    exports2.hasOwnProperty = hasOwnProperty19;
     exports2.isLisp = isLisp;
-    exports2.reservedWords = reservedWords2;
   }
 });
 
@@ -101185,9 +101199,10 @@ var require_executor = __commonJS({
       });
       return vars;
     }
+    var sandboxedFunctions = /* @__PURE__ */ new WeakSet();
     function createFunction(argNames, parsed, ticks, context, scope, name14) {
       if (context.ctx.options.forbidFunctionCreation) {
-        throw new utils.SandboxCapabilityError("Function creation is forbidden");
+        throw new utils.SandboxError("Function creation is forbidden");
       }
       let func;
       if (name14 === void 0) {
@@ -101204,15 +101219,15 @@ var require_executor = __commonJS({
         };
       }
       context.registerSandboxFunction(func);
-      context.ctx.sandboxedFunctions.add(func);
+      sandboxedFunctions.add(func);
       return func;
     }
     function createFunctionAsync(argNames, parsed, ticks, context, scope, name14) {
       if (context.ctx.options.forbidFunctionCreation) {
-        throw new utils.SandboxCapabilityError("Function creation is forbidden");
+        throw new utils.SandboxError("Function creation is forbidden");
       }
       if (!context.ctx.prototypeWhitelist?.has(Promise.prototype)) {
-        throw new utils.SandboxCapabilityError("Async/await not permitted");
+        throw new utils.SandboxError("Async/await not permitted");
       }
       let func;
       if (name14 === void 0) {
@@ -101229,40 +101244,43 @@ var require_executor = __commonJS({
         };
       }
       context.registerSandboxFunction(func);
-      context.ctx.sandboxedFunctions.add(func);
+      sandboxedFunctions.add(func);
       return func;
     }
     function assignCheck(obj, context, op2 = "assign") {
       if (obj.context === void 0) {
         throw new ReferenceError(`Cannot ${op2} value to undefined.`);
       }
+      if (typeof obj.context !== "object" && typeof obj.context !== "function") {
+        throw new SyntaxError(`Cannot ${op2} value to a primitive.`);
+      }
       if (obj.isConst) {
-        throw new TypeError(`Assignment to constant variable.`);
+        throw new TypeError(`Cannot set value to const variable '${obj.prop}'`);
       }
       if (obj.isGlobal) {
-        throw new utils.SandboxAccessError(`Cannot ${op2} property '${obj.prop.toString()}' of a global object`);
+        throw new utils.SandboxError(`Cannot ${op2} property '${obj.prop}' of a global object`);
       }
       if (obj.context === null) {
         throw new TypeError("Cannot set properties of null");
       }
-      if (typeof obj.context[obj.prop] === "function" && !utils.hasOwnProperty(obj.context, obj.prop)) {
-        throw new utils.SandboxAccessError(`Override prototype property '${obj.prop.toString()}' not allowed`);
+      if (typeof obj.context[obj.prop] === "function" && !obj.context.hasOwnProperty(obj.prop)) {
+        throw new utils.SandboxError(`Override prototype property '${obj.prop}' not allowed`);
       }
       if (op2 === "delete") {
-        if (utils.hasOwnProperty(obj.context, obj.prop)) {
-          context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb({ type: "delete", prop: obj.prop.toString() }));
-          context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb({ type: "delete", prop: obj.prop.toString() }));
+        if (obj.context.hasOwnProperty(obj.prop)) {
+          context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb({ type: "delete", prop: obj.prop }));
+          context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb({ type: "delete", prop: obj.prop }));
         }
-      } else if (utils.hasOwnProperty(obj.context, obj.prop)) {
-        context.setSubscriptions.get(obj.context)?.get(obj.prop.toString())?.forEach((cb) => cb({
+      } else if (obj.context.hasOwnProperty(obj.prop)) {
+        context.setSubscriptions.get(obj.context)?.get(obj.prop)?.forEach((cb) => cb({
           type: "replace"
         }));
-        context.setSubscriptionsGlobal.get(obj.context)?.get(obj.prop.toString())?.forEach((cb) => cb({
+        context.setSubscriptionsGlobal.get(obj.context)?.get(obj.prop)?.forEach((cb) => cb({
           type: "replace"
         }));
       } else {
-        context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb({ type: "create", prop: obj.prop.toString() }));
-        context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb({ type: "create", prop: obj.prop.toString() }));
+        context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb({ type: "create", prop: obj.prop }));
+        context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb({ type: "create", prop: obj.prop }));
       }
     }
     var arrayChange = /* @__PURE__ */ new Set([
@@ -101302,128 +101320,107 @@ var require_executor = __commonJS({
     function addOps(type, cb) {
       ops.set(type, cb);
     }
-    var prorptyKeyTypes = ["string", "number", "symbol"];
-    function isPropertyKey(val) {
-      return prorptyKeyTypes.includes(typeof val);
-    }
-    function hasPossibleProperties(val) {
-      return val !== null && val !== void 0;
-    }
-    addOps(1, ({ done, a: a4, b: b4, obj, context, scope }) => {
+    addOps(1, (exec6, done, ticks, a4, b4, obj, context, scope) => {
       if (a4 === null) {
-        throw new TypeError(`Cannot read properties of null (reading '${b4?.toString()}')`);
-      }
-      if (!isPropertyKey(b4)) {
-        b4 = `${b4}`;
+        throw new TypeError(`Cannot get property ${b4} of null`);
       }
-      if (a4 === void 0 && obj === void 0 && typeof b4 === "string") {
+      const type = typeof a4;
+      if (type === "undefined" && obj === void 0) {
         const prop = scope.get(b4);
         if (prop.context === context.ctx.sandboxGlobal) {
           if (context.ctx.options.audit) {
             context.ctx.auditReport?.globalsAccess.add(b4);
           }
+          const rep = context.ctx.globalsWhitelist.has(context.ctx.sandboxGlobal[b4]) ? context.evals.get(context.ctx.sandboxGlobal[b4]) : void 0;
+          if (rep) {
+            done(void 0, rep);
+            return;
+          }
+        }
+        if (prop.context && prop.context[b4] === globalThis) {
+          done(void 0, context.ctx.globalScope.get("this"));
+          return;
         }
-        const val2 = prop.context ? prop.context[prop.prop] : void 0;
-        const p5 = getGlobalProp(val2, context, prop) || prop;
-        done(void 0, p5);
+        done(void 0, prop);
         return;
       } else if (a4 === void 0) {
-        throw new TypeError(`Cannot read properties of undefined (reading '${b4.toString()}')`);
+        throw new utils.SandboxError("Cannot get property '" + b4 + "' of undefined");
       }
-      if (!hasPossibleProperties(a4)) {
+      if (type !== "object") {
+        if (type === "number") {
+          a4 = new Number(a4);
+        } else if (type === "string") {
+          a4 = new String(a4);
+        } else if (type === "boolean") {
+          a4 = new Boolean(a4);
+        }
+      } else if (typeof a4.hasOwnProperty === "undefined") {
         done(void 0, new utils.Prop(void 0, b4));
         return;
       }
-      const prototypeAccess = typeof a4 === "function" || !utils.hasOwnProperty(a4, b4);
+      const isFunction2 = type === "function";
+      const prototypeAccess = isFunction2 || !(a4.hasOwnProperty(b4) || typeof b4 === "number");
       if (context.ctx.options.audit && prototypeAccess) {
-        let prot = Object.getPrototypeOf(a4);
-        do {
-          if (utils.hasOwnProperty(prot, b4)) {
-            if (context.ctx.auditReport && !context.ctx.auditReport.prototypeAccess[prot.constructor.name]) {
-              context.ctx.auditReport.prototypeAccess[prot.constructor.name] = /* @__PURE__ */ new Set();
+        if (typeof b4 === "string") {
+          let prot = Object.getPrototypeOf(a4);
+          do {
+            if (prot.hasOwnProperty(b4)) {
+              if (context.ctx.auditReport && !context.ctx.auditReport.prototypeAccess[prot.constructor.name]) {
+                context.ctx.auditReport.prototypeAccess[prot.constructor.name] = /* @__PURE__ */ new Set();
+              }
+              context.ctx.auditReport?.prototypeAccess[prot.constructor.name].add(b4);
             }
-            context.ctx.auditReport?.prototypeAccess[prot.constructor.name].add(b4);
-          }
-        } while (prot = Object.getPrototypeOf(prot));
+          } while (prot = Object.getPrototypeOf(prot));
+        }
       }
       if (prototypeAccess) {
-        if (typeof a4 === "function") {
-          if (utils.hasOwnProperty(a4, b4)) {
+        if (isFunction2) {
+          if (!["name", "length", "constructor"].includes(b4) && a4.hasOwnProperty(b4)) {
             const whitelist = context.ctx.prototypeWhitelist.get(a4.prototype);
             const replace = context.ctx.options.prototypeReplacements.get(a4);
             if (replace) {
               done(void 0, new utils.Prop(replace(a4, true), b4));
               return;
             }
-            if (!(whitelist && (!whitelist.size || whitelist.has(b4))) && !context.ctx.sandboxedFunctions.has(a4)) {
-              throw new utils.SandboxAccessError(`Static method or property access not permitted: ${a4.name}.${b4.toString()}`);
+            if (!(whitelist && (!whitelist.size || whitelist.has(b4)))) {
+              throw new utils.SandboxError(`Static method or property access not permitted: ${a4.name}.${b4}`);
             }
           }
         }
-        let prot = a4;
-        while (prot = Object.getPrototypeOf(prot)) {
-          if (utils.hasOwnProperty(prot, b4) || b4 === "__proto__") {
-            const whitelist = context.ctx.prototypeWhitelist.get(prot);
-            const replace = context.ctx.options.prototypeReplacements.get(prot.constructor);
-            if (replace) {
-              done(void 0, new utils.Prop(replace(a4, false), b4));
-              return;
-            }
-            if (whitelist && (!whitelist.size || whitelist.has(b4)) || context.ctx.sandboxedFunctions.has(prot.constructor)) {
-              break;
-            }
-            if (b4 === "__proto__") {
-              throw new utils.SandboxAccessError(`Access to prototype of global object is not permitted`);
+        if (b4 !== "constructor") {
+          let prot = a4;
+          while (prot = Object.getPrototypeOf(prot)) {
+            if (prot.hasOwnProperty(b4)) {
+              const whitelist = context.ctx.prototypeWhitelist.get(prot);
+              const replace = context.ctx.options.prototypeReplacements.get(prot.constuctor);
+              if (replace) {
+                done(void 0, new utils.Prop(replace(a4, false), b4));
+                return;
+              }
+              if (whitelist && (!whitelist.size || whitelist.has(b4))) {
+                break;
+              }
+              throw new utils.SandboxError(`Method or property access not permitted: ${prot.constructor.name}.${b4}`);
             }
-            throw new utils.SandboxAccessError(`Method or property access not permitted: ${prot.constructor.name}.${b4.toString()}`);
           }
         }
       }
-      const val = a4[b4];
-      if (typeof a4 === "function") {
-        if (b4 === "prototype" && !context.ctx.sandboxedFunctions.has(a4)) {
-          throw new utils.SandboxAccessError(`Access to prototype of global object is not permitted`);
-        }
-      }
-      if (b4 === "__proto__" && !context.ctx.sandboxedFunctions.has(val?.constructor)) {
-        throw new utils.SandboxAccessError(`Access to prototype of global object is not permitted`);
-      }
-      const p4 = getGlobalProp(val, context);
-      if (p4) {
-        done(void 0, p4);
+      if (context.evals.has(a4[b4])) {
+        done(void 0, context.evals.get(a4[b4]));
         return;
       }
-      const g4 = obj instanceof utils.Prop && obj.isGlobal || typeof a4 === "function" && !context.ctx.sandboxedFunctions.has(a4) || context.ctx.globalsWhitelist.has(a4);
-      done(void 0, new utils.Prop(a4, b4, false, g4, false));
-    });
-    function getGlobalProp(val, context, prop) {
-      if (!val)
+      if (a4[b4] === globalThis) {
+        done(void 0, context.ctx.globalScope.get("this"));
         return;
-      const isFunc = typeof val === "function";
-      if (val instanceof utils.Prop) {
-        if (!prop) {
-          prop = val;
-        }
-        val = val.get(context);
-      }
-      const p4 = prop?.prop || "prop";
-      if (val === globalThis) {
-        return new utils.Prop({
-          [p4]: context.ctx.sandboxGlobal
-        }, p4, prop?.isConst || false, false, prop?.isVariable || false);
-      }
-      const evl = isFunc && context.evals.get(val);
-      if (evl) {
-        return new utils.Prop({
-          [p4]: evl
-        }, p4, prop?.isConst || false, true, prop?.isVariable || false);
       }
-    }
-    addOps(5, ({ done, a: a4, b: b4, obj, context }) => {
+      const g4 = obj.isGlobal || isFunction2 && !sandboxedFunctions.has(a4) || context.ctx.globalsWhitelist.has(a4);
+      done(void 0, new utils.Prop(a4, b4, false, g4));
+    });
+    addOps(5, (exec6, done, ticks, a4, b4, obj, context) => {
       if (context.ctx.options.forbidFunctionCalls)
-        throw new utils.SandboxCapabilityError("Function invocations are not allowed");
+        throw new utils.SandboxError("Function invocations are not allowed");
       if (typeof a4 !== "function") {
-        throw new TypeError(`${typeof obj?.prop === "symbol" ? "Symbol" : obj?.prop} is not a function`);
+        throw new TypeError(`${typeof obj.prop === "symbol" ? "Symbol" : obj.prop} is not a function`);
       }
       const vals = b4.map((item) => {
         if (item instanceof SpreadArray) {
@@ -101433,9 +101430,7 @@ var require_executor = __commonJS({
         }
       }).flat().map((item) => valueOrProp(item, context));
       if (typeof obj === "function") {
-        let ret2 = obj(...vals);
-        ret2 = getGlobalProp(ret2, context) || ret2;
-        done(void 0, ret2);
+        done(void 0, obj(...vals));
         return;
       }
       if (obj.context[obj.prop] === JSON.stringify && context.getSubscriptions.size) {
@@ -101507,11 +101502,9 @@ var require_executor = __commonJS({
         }
       }
       obj.get(context);
-      let ret = obj.context[obj.prop](...vals);
-      ret = getGlobalProp(ret, context) || ret;
-      done(void 0, ret);
+      done(void 0, obj.context[obj.prop](...vals));
     });
-    addOps(22, ({ done, b: b4 }) => {
+    addOps(22, (exec6, done, ticks, a4, b4) => {
       let res = {};
       for (const item of b4) {
         if (item.key instanceof SpreadObject) {
@@ -101522,8 +101515,8 @@ var require_executor = __commonJS({
       }
       done(void 0, res);
     });
-    addOps(6, ({ done, a: a4, b: b4 }) => done(void 0, new KeyVal(a4, b4)));
-    addOps(12, ({ done, b: b4, context }) => {
+    addOps(6, (exec6, done, ticks, a4, b4) => done(void 0, new KeyVal(a4, b4)));
+    addOps(12, (exec6, done, ticks, a4, b4, obj, context) => {
       const items = b4.map((item) => {
         if (item instanceof SpreadArray) {
           return [...item.item];
@@ -101533,8 +101526,8 @@ var require_executor = __commonJS({
       }).flat().map((item) => valueOrProp(item, context));
       done(void 0, items);
     });
-    addOps(23, ({ done, b: b4 }) => done(void 0, b4));
-    addOps(35, ({ done, b: b4 }) => {
+    addOps(23, (exec6, done, ticks, a4, b4) => done(void 0, b4));
+    addOps(35, (exec6, done, ticks, a4, b4) => {
       switch (b4) {
         case "true":
           return done(void 0, true);
@@ -101551,18 +101544,18 @@ var require_executor = __commonJS({
       }
       done(new Error("Unknown symbol: " + b4));
     });
-    addOps(7, ({ done, b: b4 }) => done(void 0, Number(b4.replace(/_/g, ""))));
-    addOps(83, ({ done, b: b4 }) => done(void 0, BigInt(b4.replace(/_/g, ""))));
-    addOps(2, ({ done, b: b4, context }) => done(void 0, context.constants.strings[parseInt(b4)]));
-    addOps(85, ({ done, b: b4, context }) => {
+    addOps(7, (exec6, done, ticks, a4, b4) => done(void 0, Number(b4)));
+    addOps(83, (exec6, done, ticks, a4, b4) => done(void 0, BigInt(b4)));
+    addOps(2, (exec6, done, ticks, a4, b4, obj, context) => done(void 0, context.constants.strings[parseInt(b4)]));
+    addOps(86, (exec6, done, ticks, a4, b4, obj, context) => {
       const reg = context.constants.regexes[parseInt(b4)];
       if (!context.ctx.globalsWhitelist.has(RegExp)) {
-        throw new utils.SandboxCapabilityError("Regex not permitted");
+        throw new utils.SandboxError("Regex not permitted");
       } else {
         done(void 0, new RegExp(reg.regex, reg.flags));
       }
     });
-    addOps(84, ({ exec: exec6, done, ticks, b: b4, context, scope }) => {
+    addOps(84, (exec6, done, ticks, a4, b4, obj, context, scope) => {
       const item = context.constants.literals[parseInt(b4)];
       const [, name14, js] = item;
       const found = [];
@@ -101574,13 +101567,12 @@ var require_executor = __commonJS({
           resnums.push(f4[3]);
         }
       }
-      exec6(ticks, found, scope, context, (...args) => {
+      exec6(ticks, found, scope, context, (err, processed) => {
         const reses = {};
-        if (args.length === 1) {
-          done(args[0]);
+        if (err) {
+          done(err);
           return;
         }
-        const processed = args[1];
         for (const i4 of Object.keys(processed)) {
           const num = resnums[i4];
           reses[num] = processed[i4];
@@ -101593,146 +101585,115 @@ var require_executor = __commonJS({
         }));
       });
     });
-    addOps(18, ({ done, b: b4 }) => {
+    addOps(18, (exec6, done, ticks, a4, b4) => {
       done(void 0, new SpreadArray(b4));
     });
-    addOps(17, ({ done, b: b4 }) => {
+    addOps(17, (exec6, done, ticks, a4, b4) => {
       done(void 0, new SpreadObject(b4));
     });
-    addOps(24, ({ done, b: b4 }) => done(void 0, !b4));
-    addOps(64, ({ done, b: b4 }) => done(void 0, ~b4));
-    addOps(25, ({ done, obj, context }) => {
+    addOps(24, (exec6, done, ticks, a4, b4) => done(void 0, !b4));
+    addOps(64, (exec6, done, ticks, a4, b4) => done(void 0, ~b4));
+    addOps(25, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, ++obj.context[obj.prop]);
     });
-    addOps(26, ({ done, obj, context }) => {
+    addOps(26, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop]++);
     });
-    addOps(27, ({ done, obj, context }) => {
+    addOps(27, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, --obj.context[obj.prop]);
     });
-    addOps(28, ({ done, obj, context }) => {
+    addOps(28, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop]--);
     });
-    addOps(9, ({ done, b: b4, obj, context, scope, bobj }) => {
+    addOps(9, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
-      obj.isGlobal = bobj?.isGlobal || false;
-      if (obj.isVariable) {
-        const s4 = scope.getWhereValScope(obj.prop, obj.prop === "this");
-        if (s4 === null) {
-          throw new ReferenceError(`Cannot assign to undeclared variable '${obj.prop.toString()}'`);
-        }
-        s4.set(obj.prop, b4);
-        if (obj.isGlobal) {
-          s4.globals[obj.prop.toString()] = true;
-        } else {
-          delete s4.globals[obj.prop.toString()];
-        }
-        done(void 0, b4);
-        return;
-      }
       done(void 0, obj.context[obj.prop] = b4);
     });
-    addOps(66, ({ done, b: b4, obj, context }) => {
+    addOps(66, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] += b4);
     });
-    addOps(65, ({ done, b: b4, obj, context }) => {
+    addOps(65, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] -= b4);
     });
-    addOps(67, ({ done, b: b4, obj, context }) => {
+    addOps(67, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] /= b4);
     });
-    addOps(69, ({ done, b: b4, obj, context }) => {
+    addOps(69, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] *= b4);
     });
-    addOps(68, ({ done, b: b4, obj, context }) => {
+    addOps(68, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] **= b4);
     });
-    addOps(70, ({ done, b: b4, obj, context }) => {
+    addOps(70, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] %= b4);
     });
-    addOps(71, ({ done, b: b4, obj, context }) => {
+    addOps(71, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] ^= b4);
     });
-    addOps(72, ({ done, b: b4, obj, context }) => {
+    addOps(72, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] &= b4);
     });
-    addOps(73, ({ done, b: b4, obj, context }) => {
+    addOps(73, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] |= b4);
     });
-    addOps(76, ({ done, b: b4, obj, context }) => {
+    addOps(76, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] <<= b4);
     });
-    addOps(75, ({ done, b: b4, obj, context }) => {
+    addOps(75, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
       done(void 0, obj.context[obj.prop] >>= b4);
     });
-    addOps(74, ({ done, b: b4, obj, context }) => {
-      assignCheck(obj, context);
-      done(void 0, obj.context[obj.prop] >>>= b4);
-    });
-    addOps(90, ({ done, b: b4, obj, context }) => {
-      var _a16, _b;
-      assignCheck(obj, context);
-      done(void 0, (_a16 = obj.context)[_b = obj.prop] && (_a16[_b] = b4));
-    });
-    addOps(91, ({ done, b: b4, obj, context }) => {
-      var _a16, _b;
-      assignCheck(obj, context);
-      done(void 0, (_a16 = obj.context)[_b = obj.prop] || (_a16[_b] = b4));
-    });
-    addOps(92, ({ done, b: b4, obj, context }) => {
-      var _a16, _b;
+    addOps(74, (exec6, done, ticks, a4, b4, obj, context) => {
       assignCheck(obj, context);
-      done(void 0, (_a16 = obj.context)[_b = obj.prop] ?? (_a16[_b] = b4));
+      done(void 0, obj.context[obj.prop] >>= b4);
     });
-    addOps(57, ({ done, a: a4, b: b4 }) => done(void 0, a4 > b4));
-    addOps(56, ({ done, a: a4, b: b4 }) => done(void 0, a4 < b4));
-    addOps(55, ({ done, a: a4, b: b4 }) => done(void 0, a4 >= b4));
-    addOps(54, ({ done, a: a4, b: b4 }) => done(void 0, a4 <= b4));
-    addOps(52, ({ done, a: a4, b: b4 }) => done(void 0, a4 == b4));
-    addOps(32, ({ done, a: a4, b: b4 }) => done(void 0, a4 === b4));
-    addOps(53, ({ done, a: a4, b: b4 }) => done(void 0, a4 != b4));
-    addOps(31, ({ done, a: a4, b: b4 }) => done(void 0, a4 !== b4));
-    addOps(29, ({ done, a: a4, b: b4 }) => done(void 0, a4 && b4));
-    addOps(30, ({ done, a: a4, b: b4 }) => done(void 0, a4 || b4));
-    addOps(89, ({ done, a: a4, b: b4 }) => done(void 0, a4 ?? b4));
-    addOps(77, ({ done, a: a4, b: b4 }) => done(void 0, a4 & b4));
-    addOps(78, ({ done, a: a4, b: b4 }) => done(void 0, a4 | b4));
-    addOps(33, ({ done, a: a4, b: b4 }) => done(void 0, a4 + b4));
-    addOps(47, ({ done, a: a4, b: b4 }) => done(void 0, a4 - b4));
-    addOps(59, ({ done, b: b4 }) => done(void 0, +b4));
-    addOps(58, ({ done, b: b4 }) => done(void 0, -b4));
-    addOps(48, ({ done, a: a4, b: b4 }) => done(void 0, a4 / b4));
-    addOps(49, ({ done, a: a4, b: b4 }) => done(void 0, a4 ** b4));
-    addOps(79, ({ done, a: a4, b: b4 }) => done(void 0, a4 ^ b4));
-    addOps(50, ({ done, a: a4, b: b4 }) => done(void 0, a4 * b4));
-    addOps(51, ({ done, a: a4, b: b4 }) => done(void 0, a4 % b4));
-    addOps(80, ({ done, a: a4, b: b4 }) => done(void 0, a4 << b4));
-    addOps(81, ({ done, a: a4, b: b4 }) => done(void 0, a4 >> b4));
-    addOps(82, ({ done, a: a4, b: b4 }) => done(void 0, a4 >>> b4));
-    addOps(60, ({ exec: exec6, done, ticks, b: b4, context, scope }) => {
+    addOps(57, (exec6, done, ticks, a4, b4) => done(void 0, a4 > b4));
+    addOps(56, (exec6, done, ticks, a4, b4) => done(void 0, a4 < b4));
+    addOps(55, (exec6, done, ticks, a4, b4) => done(void 0, a4 >= b4));
+    addOps(54, (exec6, done, ticks, a4, b4) => done(void 0, a4 <= b4));
+    addOps(52, (exec6, done, ticks, a4, b4) => done(void 0, a4 == b4));
+    addOps(32, (exec6, done, ticks, a4, b4) => done(void 0, a4 === b4));
+    addOps(53, (exec6, done, ticks, a4, b4) => done(void 0, a4 != b4));
+    addOps(31, (exec6, done, ticks, a4, b4) => done(void 0, a4 !== b4));
+    addOps(29, (exec6, done, ticks, a4, b4) => done(void 0, a4 && b4));
+    addOps(30, (exec6, done, ticks, a4, b4) => done(void 0, a4 || b4));
+    addOps(85, (exec6, done, ticks, a4, b4) => done(void 0, a4 ?? b4));
+    addOps(77, (exec6, done, ticks, a4, b4) => done(void 0, a4 & b4));
+    addOps(78, (exec6, done, ticks, a4, b4) => done(void 0, a4 | b4));
+    addOps(33, (exec6, done, ticks, a4, b4) => done(void 0, a4 + b4));
+    addOps(47, (exec6, done, ticks, a4, b4) => done(void 0, a4 - b4));
+    addOps(59, (exec6, done, ticks, a4, b4) => done(void 0, +b4));
+    addOps(58, (exec6, done, ticks, a4, b4) => done(void 0, -b4));
+    addOps(48, (exec6, done, ticks, a4, b4) => done(void 0, a4 / b4));
+    addOps(79, (exec6, done, ticks, a4, b4) => done(void 0, a4 ^ b4));
+    addOps(50, (exec6, done, ticks, a4, b4) => done(void 0, a4 * b4));
+    addOps(51, (exec6, done, ticks, a4, b4) => done(void 0, a4 % b4));
+    addOps(80, (exec6, done, ticks, a4, b4) => done(void 0, a4 << b4));
+    addOps(81, (exec6, done, ticks, a4, b4) => done(void 0, a4 >> b4));
+    addOps(82, (exec6, done, ticks, a4, b4) => done(void 0, a4 >>> b4));
+    addOps(60, (exec6, done, ticks, a4, b4, obj, context, scope) => {
       exec6(ticks, b4, scope, context, (e4, prop) => {
         done(void 0, typeof valueOrProp(prop, context));
       });
     });
-    addOps(62, ({ done, a: a4, b: b4 }) => done(void 0, a4 instanceof b4));
-    addOps(63, ({ done, a: a4, b: b4 }) => done(void 0, a4 in b4));
-    addOps(61, ({ done, context, bobj }) => {
-      if (!(bobj instanceof utils.Prop)) {
+    addOps(62, (exec6, done, ticks, a4, b4) => done(void 0, a4 instanceof b4));
+    addOps(63, (exec6, done, ticks, a4, b4) => done(void 0, a4 in b4));
+    addOps(61, (exec6, done, ticks, a4, b4, obj, context, scope, bobj) => {
+      if (bobj.context === void 0) {
         done(void 0, true);
         return;
       }
@@ -101743,23 +101704,23 @@ var require_executor = __commonJS({
       }
       done(void 0, delete bobj.context?.[bobj.prop]);
     });
-    addOps(8, ({ done, b: b4 }) => done(void 0, b4));
-    addOps(34, ({ done, a: a4, b: b4, scope, bobj }) => {
-      done(void 0, scope.declare(a4, "var", b4, bobj?.isGlobal || false));
+    addOps(8, (exec6, done, ticks, a4, b4) => done(void 0, b4));
+    addOps(34, (exec6, done, ticks, a4, b4, obj, context, scope) => {
+      done(void 0, scope.declare(a4, "var", b4));
     });
-    addOps(3, ({ done, a: a4, b: b4, scope, bobj }) => {
-      done(void 0, scope.declare(a4, "let", b4, bobj?.isGlobal || false));
+    addOps(3, (exec6, done, ticks, a4, b4, obj, context, scope, bobj) => {
+      done(void 0, scope.declare(a4, "let", b4, bobj && bobj.isGlobal));
     });
-    addOps(4, ({ done, a: a4, b: b4, scope, bobj }) => {
-      done(void 0, scope.declare(a4, "const", b4, bobj?.isGlobal || false));
+    addOps(4, (exec6, done, ticks, a4, b4, obj, context, scope) => {
+      done(void 0, scope.declare(a4, "const", b4));
     });
-    addOps(11, ({ done, ticks, a: a4, b: b4, obj, context, scope }) => {
+    addOps(11, (exec6, done, ticks, a4, b4, obj, context, scope) => {
       a4 = [...a4];
       if (typeof obj[2] === "string" || obj[2] instanceof utils.CodeString) {
         if (context.allowJit && context.evalContext) {
           obj[2] = b4 = context.evalContext.lispifyFunction(new utils.CodeString(obj[2]), context.constants);
         } else {
-          throw new utils.SandboxCapabilityError("Unevaluated code detected, JIT not allowed");
+          throw new utils.SandboxError("Unevaluated code detected, JIT not allowed");
         }
       }
       if (a4.shift()) {
@@ -101768,18 +101729,18 @@ var require_executor = __commonJS({
         done(void 0, createFunction(a4, b4, ticks, context, scope));
       }
     });
-    addOps(37, ({ done, ticks, a: a4, b: b4, obj, context, scope }) => {
+    addOps(37, (exec6, done, ticks, a4, b4, obj, context, scope) => {
       if (typeof obj[2] === "string" || obj[2] instanceof utils.CodeString) {
         if (context.allowJit && context.evalContext) {
           obj[2] = b4 = context.evalContext.lispifyFunction(new utils.CodeString(obj[2]), context.constants);
         } else {
-          throw new utils.SandboxCapabilityError("Unevaluated code detected, JIT not allowed");
+          throw new utils.SandboxError("Unevaluated code detected, JIT not allowed");
         }
       }
       const isAsync2 = a4.shift();
       const name14 = a4.shift();
       let func;
-      if (isAsync2 === 88) {
+      if (isAsync2 === 89) {
         func = createFunctionAsync(a4, b4, ticks, context, scope, name14);
       } else {
         func = createFunction(a4, b4, ticks, context, scope, name14);
@@ -101789,12 +101750,12 @@ var require_executor = __commonJS({
       }
       done(void 0, func);
     });
-    addOps(10, ({ done, ticks, a: a4, b: b4, obj, context, scope }) => {
+    addOps(10, (exec6, done, ticks, a4, b4, obj, context, scope) => {
       if (typeof obj[2] === "string" || obj[2] instanceof utils.CodeString) {
         if (context.allowJit && context.evalContext) {
           obj[2] = b4 = context.evalContext.lispifyFunction(new utils.CodeString(obj[2]), context.constants);
         } else {
-          throw new utils.SandboxCapabilityError("Unevaluated code detected, JIT not allowed");
+          throw new utils.SandboxError("Unevaluated code detected, JIT not allowed");
         }
       }
       const isAsync2 = a4.shift();
@@ -101803,7 +101764,7 @@ var require_executor = __commonJS({
         scope = new utils.Scope(scope, {});
       }
       let func;
-      if (isAsync2 === 88) {
+      if (isAsync2 === 89) {
         func = createFunctionAsync(a4, b4, ticks, context, scope, name14);
       } else {
         func = createFunction(a4, b4, ticks, context, scope, name14);
@@ -101813,7 +101774,7 @@ var require_executor = __commonJS({
       }
       done(void 0, func);
     });
-    addOps(38, ({ exec: exec6, done, ticks, a: a4, b: b4, context, scope }) => {
+    addOps(38, (exec6, done, ticks, a4, b4, obj, context, scope) => {
       const [checkFirst, startInternal, getIterator, startStep, step, condition, beforeStep] = a4;
       let loop = true;
       const loopScope = new utils.Scope(scope, {});
@@ -101869,27 +101830,26 @@ var require_executor = __commonJS({
         done();
       }
     });
-    addOps(86, ({ done, a: a4, context, inLoopOrSwitch }) => {
+    addOps(87, (exec6, done, ticks, a4, b4, obj, context, scope, bobj, inLoopOrSwitch) => {
       if (inLoopOrSwitch === "switch" && a4 === "continue" || !inLoopOrSwitch) {
-        throw new TypeError("Illegal " + a4 + " statement");
+        throw new utils.SandboxError("Illegal " + a4 + " statement");
       }
       done(void 0, new ExecReturn(context.ctx.auditReport, void 0, false, a4 === "break", a4 === "continue"));
     });
-    addOps(13, ({ exec: exec6, done, ticks, a: a4, b: b4, context, scope, inLoopOrSwitch }) => {
+    addOps(13, (exec6, done, ticks, a4, b4, obj, context, scope, bobj, inLoopOrSwitch) => {
       exec6(ticks, valueOrProp(a4, context) ? b4.t : b4.f, scope, context, done, inLoopOrSwitch);
     });
-    addOps(15, ({ exec: exec6, done, ticks, a: a4, b: b4, context, scope }) => {
-      exec6(ticks, valueOrProp(a4, context) ? b4.t : b4.f, scope, context, done, void 0);
+    addOps(15, (exec6, done, ticks, a4, b4, obj, context, scope, bobj, inLoopOrSwitch) => {
+      exec6(ticks, valueOrProp(a4, context) ? b4.t : b4.f, scope, context, done, inLoopOrSwitch);
     });
-    addOps(16, ({ done, a: a4, b: b4 }) => done(void 0, new If(a4, b4)));
-    addOps(14, ({ done, a: a4, b: b4 }) => done(void 0, new If(a4, b4)));
-    addOps(40, ({ exec: exec6, done, ticks, a: a4, b: b4, context, scope }) => {
-      exec6(ticks, a4, scope, context, (...args) => {
-        if (args.length === 1) {
-          done(args[0]);
+    addOps(16, (exec6, done, ticks, a4, b4) => done(void 0, new If(a4, b4)));
+    addOps(14, (exec6, done, ticks, a4, b4) => done(void 0, new If(a4, b4)));
+    addOps(40, (exec6, done, ticks, a4, b4, obj, context, scope) => {
+      exec6(ticks, a4, scope, context, (err, toTest) => {
+        if (err) {
+          done(err);
           return;
         }
-        let toTest = args[1];
         toTest = valueOrProp(toTest, context);
         if (exec6 === execSync) {
           let res;
@@ -101937,79 +101897,34 @@ var require_executor = __commonJS({
         }
       });
     });
-    addOps(39, ({ exec: exec6, done, ticks, a: a4, b: b4, context, scope, inLoopOrSwitch }) => {
+    addOps(39, (exec6, done, ticks, a4, b4, obj, context, scope, bobj, inLoopOrSwitch) => {
       const [exception, catchBody, finallyBody] = b4;
-      executeTreeWithDone(exec6, (...tryArgs) => {
-        const tryHadError = tryArgs.length === 1;
-        const tryError = tryHadError ? tryArgs[0] : void 0;
-        const tryResult = !tryHadError && tryArgs.length > 1 ? tryArgs[1] : void 0;
-        const executeFinallyAndComplete = (hadError, errorOrResult) => {
-          if (finallyBody && finallyBody.length > 0) {
-            executeTreeWithDone(exec6, (...finallyArgs) => {
-              const finallyHadError = finallyArgs.length === 1;
-              const finallyResult = !finallyHadError && finallyArgs.length > 1 ? finallyArgs[1] : void 0;
-              if (finallyHadError) {
-                done(finallyArgs[0]);
-                return;
-              }
-              if (finallyResult instanceof ExecReturn && (finallyResult.returned || finallyResult.breakLoop || finallyResult.continueLoop)) {
-                done(void 0, finallyResult);
-                return;
-              }
-              if (hadError) {
-                done(errorOrResult);
-              } else if (errorOrResult instanceof ExecReturn) {
-                if (errorOrResult.returned || errorOrResult.breakLoop || errorOrResult.continueLoop) {
-                  done(void 0, errorOrResult);
-                } else {
-                  done();
-                }
-              } else {
-                done();
-              }
-            }, ticks, context, finallyBody, [new utils.Scope(scope, {})], inLoopOrSwitch);
+      executeTreeWithDone(exec6, (err, res) => {
+        executeTreeWithDone(exec6, (e4) => {
+          if (e4)
+            done(e4);
+          else if (err) {
+            executeTreeWithDone(exec6, done, ticks, context, catchBody, [new utils.Scope(scope)], inLoopOrSwitch);
           } else {
-            if (hadError) {
-              done(errorOrResult);
-            } else if (errorOrResult instanceof ExecReturn) {
-              if (errorOrResult.returned || errorOrResult.breakLoop || errorOrResult.continueLoop) {
-                done(void 0, errorOrResult);
-              } else {
-                done();
-              }
-            } else {
-              done();
-            }
+            done(void 0, res);
           }
-        };
-        if (tryHadError && catchBody && catchBody.length > 0) {
-          const sc = {};
-          if (exception)
-            sc[exception] = tryError;
-          executeTreeWithDone(exec6, (...catchArgs) => {
-            const catchHadError = catchArgs.length === 1;
-            const catchErrorOrResult = catchHadError ? catchArgs[0] : catchArgs.length > 1 ? catchArgs[1] : void 0;
-            executeFinallyAndComplete(catchHadError, catchErrorOrResult);
-          }, ticks, context, catchBody, [new utils.Scope(scope, sc)], inLoopOrSwitch);
-        } else {
-          executeFinallyAndComplete(tryHadError, tryHadError ? tryError : tryResult);
-        }
+        }, ticks, context, finallyBody, [new utils.Scope(scope, {})]);
       }, ticks, context, a4, [new utils.Scope(scope)], inLoopOrSwitch);
     });
-    addOps(87, ({ done }) => {
+    addOps(88, (exec6, done) => {
       done();
     });
-    addOps(45, ({ done, a: a4, b: b4, context }) => {
-      if (!context.ctx.globalsWhitelist.has(a4) && !context.ctx.sandboxedFunctions.has(a4)) {
-        throw new utils.SandboxAccessError(`Object construction not allowed: ${a4.constructor.name}`);
+    addOps(45, (exec6, done, ticks, a4, b4, obj, context) => {
+      if (!context.ctx.globalsWhitelist.has(a4) && !sandboxedFunctions.has(a4)) {
+        throw new utils.SandboxError(`Object construction not allowed: ${a4.constructor.name}`);
       }
       done(void 0, new a4(...b4));
     });
-    addOps(46, ({ done, b: b4 }) => {
+    addOps(46, (exec6, done, ticks, a4, b4) => {
       done(b4);
     });
-    addOps(43, ({ done, a: a4 }) => done(void 0, a4.pop()));
-    addOps(0, ({ done }) => done());
+    addOps(43, (exec6, done, ticks, a4) => done(void 0, a4.pop()));
+    addOps(0, (exec6, done) => done());
     function valueOrProp(a4, context) {
       if (a4 instanceof utils.Prop)
         return a4.get(context);
@@ -102027,7 +101942,13 @@ var require_executor = __commonJS({
     function _execManySync(ticks, tree, done, scope, context, inLoopOrSwitch) {
       const ret = [];
       for (let i4 = 0; i4 < tree.length; i4++) {
-        let res = syncDone((d4) => execSync(ticks, tree[i4], scope, context, d4, inLoopOrSwitch)).result;
+        let res;
+        try {
+          res = syncDone((d4) => execSync(ticks, tree[i4], scope, context, d4, inLoopOrSwitch)).result;
+        } catch (e4) {
+          done(e4);
+          return;
+        }
         if (res instanceof ExecReturn && (res.returned || res.breakLoop || res.continueLoop)) {
           done(void 0, res);
           return;
@@ -102067,13 +101988,13 @@ var require_executor = __commonJS({
       let isInstant = false;
       let instant;
       const p4 = new Promise((resolve7, reject2) => {
-        callback((...args) => {
-          if (args.length === 1)
-            reject2(args[0]);
+        callback((err, result) => {
+          if (err)
+            reject2(err);
           else {
             isInstant = true;
-            instant = args[1];
-            resolve7({ result: args[1] });
+            instant = result;
+            resolve7({ result });
           }
         });
       });
@@ -102086,19 +102007,19 @@ var require_executor = __commonJS({
     function syncDone(callback) {
       let result;
       let err;
-      callback((...args) => {
-        err = args.length === 1 ? { error: args[0] } : void 0;
-        result = args[1];
+      callback((e4, r4) => {
+        err = e4;
+        result = r4;
       });
       if (err)
-        throw err.error;
+        throw err;
       return { result };
     }
     async function execAsync4(ticks, tree, scope, context, doneOriginal, inLoopOrSwitch) {
       let done = doneOriginal;
       const p4 = new Promise((resolve7) => {
-        done = (...args) => {
-          doneOriginal(...args);
+        done = (e4, r4) => {
+          doneOriginal(e4, r4);
           resolve7();
         };
       });
@@ -102134,10 +102055,6 @@ var require_executor = __commonJS({
             a4 = void 0;
           }
         }
-        if (op2 === 89 && a4 !== void 0 && a4 !== null) {
-          done(void 0, a4);
-          return;
-        }
         let bobj;
         try {
           let ad;
@@ -102156,28 +102073,35 @@ var require_executor = __commonJS({
         if (b4 === optional) {
           b4 = void 0;
         }
-        performOp({
-          op: op2,
-          exec: execAsync4,
-          done,
-          ticks,
-          a: a4,
-          b: b4,
-          obj,
-          context,
-          scope,
-          bobj,
-          inLoopOrSwitch,
-          tree
-        });
+        if (ops.has(op2)) {
+          try {
+            ops.get(op2)?.(execAsync4, done, ticks, a4, b4, obj, context, scope, bobj, inLoopOrSwitch);
+          } catch (err) {
+            done(err);
+          }
+        } else {
+          done(new SyntaxError("Unknown operator: " + op2));
+        }
       }
       await p4;
     }
     function execSync(ticks, tree, scope, context, done, inLoopOrSwitch) {
       if (!_execNoneRecurse(ticks, tree, scope, context, done, false, inLoopOrSwitch) && utils.isLisp(tree)) {
         let op2 = tree[0];
-        let obj = syncDone((d4) => execSync(ticks, tree[1], scope, context, d4, inLoopOrSwitch)).result;
-        let a4 = obj instanceof utils.Prop ? obj.get(context) : obj;
+        let obj;
+        try {
+          obj = syncDone((d4) => execSync(ticks, tree[1], scope, context, d4, inLoopOrSwitch)).result;
+        } catch (e4) {
+          done(e4);
+          return;
+        }
+        let a4 = obj;
+        try {
+          a4 = obj instanceof utils.Prop ? obj.get(context) : obj;
+        } catch (e4) {
+          done(e4);
+          return;
+        }
         if (op2 === 20 || op2 === 21) {
           if (a4 === void 0 || a4 === null) {
             done(void 0, optional);
@@ -102193,129 +102117,31 @@ var require_executor = __commonJS({
             a4 = void 0;
           }
         }
-        if (op2 === 89 && a4 !== void 0 && a4 !== null) {
-          done(void 0, a4);
+        let bobj;
+        try {
+          bobj = syncDone((d4) => execSync(ticks, tree[2], scope, context, d4, inLoopOrSwitch)).result;
+        } catch (e4) {
+          done(e4);
+          return;
+        }
+        let b4 = bobj;
+        try {
+          b4 = bobj instanceof utils.Prop ? bobj.get(context) : bobj;
+        } catch (e4) {
+          done(e4);
           return;
         }
-        let bobj = syncDone((d4) => execSync(ticks, tree[2], scope, context, d4, inLoopOrSwitch)).result;
-        let b4 = bobj instanceof utils.Prop ? bobj.get(context) : bobj;
         if (b4 === optional) {
           b4 = void 0;
         }
-        performOp({
-          op: op2,
-          exec: execSync,
-          done,
-          ticks,
-          a: a4,
-          b: b4,
-          obj,
-          context,
-          scope,
-          bobj,
-          inLoopOrSwitch,
-          tree
-        });
-      }
-    }
-    function checkHaltExpectedTicks(params, expectTicks = 0) {
-      const sandbox = params.context.ctx.sandbox;
-      const options = params.context.ctx.options;
-      const { ticks, scope, context, done, op: op2 } = params;
-      if (sandbox.halted) {
-        const sub = sandbox.subscribeResume(() => {
-          sub.unsubscribe();
+        if (ops.has(op2)) {
           try {
-            const o4 = ops.get(op2);
-            if (!o4) {
-              done(new SyntaxError("Unknown operator: " + op2));
-              return;
-            }
-            o4(params);
-          } catch (err) {
-            if (options.haltOnSandboxError && err instanceof utils.SandboxError) {
-              const sub2 = sandbox.subscribeResume(() => {
-                sub2.unsubscribe();
-                done(err);
-              });
-              sandbox.haltExecution({
-                error: err,
-                ticks,
-                scope,
-                context
-              });
-            } else {
-              done(err);
-            }
-          }
-        });
-        return true;
-      } else if (ticks.tickLimit && ticks.tickLimit <= ticks.ticks + BigInt(expectTicks)) {
-        const sub = sandbox.subscribeResume(() => {
-          sub.unsubscribe();
-          try {
-            const o4 = ops.get(op2);
-            if (!o4) {
-              done(new SyntaxError("Unknown operator: " + op2));
-              return;
-            }
-            o4(params);
+            ops.get(op2)?.(execSync, done, ticks, a4, b4, obj, context, scope, bobj, inLoopOrSwitch);
           } catch (err) {
-            if (context.ctx.options.haltOnSandboxError && err instanceof utils.SandboxError) {
-              const sub2 = sandbox.subscribeResume(() => {
-                sub2.unsubscribe();
-                done(err);
-              });
-              sandbox.haltExecution({
-                error: err,
-                ticks,
-                scope,
-                context
-              });
-            } else {
-              done(err);
-            }
-          }
-        });
-        const error2 = new utils.SandboxExecutionQuotaExceededError("Execution quota exceeded");
-        sandbox.haltExecution({
-          error: error2,
-          ticks,
-          scope,
-          context
-        });
-        return true;
-      }
-      return false;
-    }
-    function performOp(params) {
-      const { done, op: op2, ticks, context, scope } = params;
-      ticks.ticks++;
-      const sandbox = context.ctx.sandbox;
-      if (checkHaltExpectedTicks(params)) {
-        return;
-      }
-      try {
-        const o4 = ops.get(op2);
-        if (!o4) {
-          done(new utils.SandboxExecutionTreeError("Unknown operator: " + op2));
-          return;
-        }
-        o4(params);
-      } catch (err) {
-        if (context.ctx.options.haltOnSandboxError && err instanceof utils.SandboxError) {
-          const sub = sandbox.subscribeResume(() => {
-            sub.unsubscribe();
             done(err);
-          });
-          sandbox.haltExecution({
-            error: err,
-            ticks,
-            scope,
-            context
-          });
+          }
         } else {
-          done(err);
+          done(new SyntaxError("Unknown operator: " + op2));
         }
       }
     }
@@ -102333,9 +102159,20 @@ var require_executor = __commonJS({
     var currentTicks = { current: { ticks: BigInt(0) } };
     function _execNoneRecurse(ticks, tree, scope, context, done, isAsync2, inLoopOrSwitch) {
       const exec6 = isAsync2 ? execAsync4 : execSync;
+      if (context.ctx.options.executionQuota && context.ctx.options.executionQuota <= ticks.ticks) {
+        if (!(typeof context.ctx.options.onExecutionQuotaReached === "function" && context.ctx.options.onExecutionQuotaReached(ticks, scope, context, tree))) {
+          done(new utils.SandboxError("Execution quota exceeded"));
+          return true;
+        }
+      }
+      ticks.ticks++;
       currentTicks.current = ticks;
       if (tree instanceof utils.Prop) {
-        done(void 0, tree.get(context));
+        try {
+          done(void 0, tree.get(context));
+        } catch (err) {
+          done(err);
+        }
       } else if (tree === optional) {
         done();
       } else if (Array.isArray(tree) && !utils.isLisp(tree)) {
@@ -102350,36 +102187,27 @@ var require_executor = __commonJS({
         execMany(ticks, exec6, tree[1], done, scope, context, inLoopOrSwitch);
       } else if (tree[0] === 44) {
         if (!isAsync2) {
-          done(new SyntaxError("Illegal use of 'await', must be inside async function"));
+          done(new utils.SandboxError("Illegal use of 'await', must be inside async function"));
         } else if (context.ctx.prototypeWhitelist?.has(Promise.prototype)) {
-          execAsync4(ticks, tree[1], scope, context, async (...args) => {
-            if (args.length === 1)
-              done(args[0]);
+          execAsync4(ticks, tree[1], scope, context, async (e4, r4) => {
+            if (e4)
+              done(e4);
             else
               try {
-                done(void 0, await valueOrProp(args[1], context));
+                done(void 0, await valueOrProp(r4, context));
               } catch (err) {
                 done(err);
               }
           }, inLoopOrSwitch).catch(done);
         } else {
-          done(new utils.SandboxCapabilityError("Async/await is not permitted"));
+          done(new utils.SandboxError("Async/await is not permitted"));
         }
       } else if (unexecTypes.has(tree[0])) {
-        performOp({
-          op: tree[0],
-          exec: exec6,
-          done,
-          ticks,
-          a: tree[1],
-          b: tree[2],
-          obj: tree,
-          tree,
-          context,
-          scope,
-          bobj: void 0,
-          inLoopOrSwitch
-        });
+        try {
+          ops.get(tree[0])?.(exec6, done, ticks, tree[1], tree[2], tree, context, scope, void 0, inLoopOrSwitch);
+        } catch (err) {
+          done(err);
+        }
       } else {
         return false;
       }
@@ -102432,17 +102260,15 @@ var require_executor = __commonJS({
         let err;
         const current2 = executionTree[i4];
         try {
-          execSync(ticks, current2, scope, context, (...args) => {
-            if (args.length === 1)
-              err = { error: args[0] };
-            else
-              res = args[1];
+          execSync(ticks, current2, scope, context, (e4, r4) => {
+            err = e4;
+            res = r4;
           }, inLoopOrSwitch);
         } catch (e4) {
-          err = { error: e4 };
+          err = e4;
         }
         if (err) {
-          done(err.error);
+          done(err);
           return;
         }
         if (res instanceof ExecReturn) {
@@ -102465,17 +102291,15 @@ var require_executor = __commonJS({
         let err;
         const current2 = executionTree[i4];
         try {
-          await execAsync4(ticks, current2, scope, context, (...args) => {
-            if (args.length === 1)
-              err = { error: args[0] };
-            else
-              res = args[1];
+          await execAsync4(ticks, current2, scope, context, (e4, r4) => {
+            err = e4;
+            res = r4;
           }, inLoopOrSwitch);
         } catch (e4) {
-          err = { error: e4 };
+          err = e4;
         }
         if (err) {
-          done(err.error);
+          done(err);
           return;
         }
         if (res instanceof ExecReturn) {
@@ -102506,6 +102330,7 @@ var require_executor = __commonJS({
     exports2.executeTree = executeTree;
     exports2.executeTreeAsync = executeTreeAsync;
     exports2.ops = ops;
+    exports2.sandboxedFunctions = sandboxedFunctions;
     exports2.syncDone = syncDone;
   }
 });
@@ -102620,29 +102445,23 @@ var require_parser2 = __commonJS({
     var expectTypes = {
       splitter: {
         types: {
-          power: /^(\*\*)(?!=)/,
-          opHigh: /^(\/|\*(?!\*)|%)(?!=)/,
+          opHigh: /^(\/|\*\*|\*(?!\*)|%)(?!=)/,
           op: /^(\+(?!(\+))|-(?!(-)))(?!=)/,
           comparitor: /^(<=|>=|<(?!<)|>(?!>)|!==|!=(?!=)|===|==)/,
-          bitwiseShift: /^(<<|>>(?!>)|>>>)(?!=)/,
-          bitwiseAnd: /^(&(?!&))(?!=)/,
-          bitwiseXor: /^(\^)(?!=)/,
-          bitwiseOr: /^(\|(?!\|))(?!=)/,
-          boolOpAnd: /^(&&)(?!=)/,
-          boolOpOr: /^(\|\|(?!=)|instanceof(?![\w$])|in(?![\w$]))/,
-          nullishCoalescing: /^\?\?(?!=)/
+          boolOp: /^(&&|\|\||\?\?|instanceof(?![\w$])|in(?![\w$]))/,
+          bitwise: /^(&(?!&)|\|(?!\|)|\^|<<|>>(?!>)|>>>)(?!=)/
         },
         next: ["modifier", "value", "prop", "incrementerBefore"]
       },
       inlineIf: {
         types: {
-          inlineIf: /^\?(?!\.(?!\d))/
+          inlineIf: /^\?(?!\?|\.(?!\d))/
         },
         next: ["expEnd"]
       },
       assignment: {
         types: {
-          assignModify: /^(-=|\+=|\/=|\*\*=|\*=|%=|\^=|&=|\|=|>>>=|>>=|<<=|&&=|\|\|=|\?\?=)/,
+          assignModify: /^(-=|\+=|\/=|\*\*=|\*=|%=|\^=|&=|\|=|>>>=|>>=|<<=)/,
           assign: /^(=)(?!=)/
         },
         next: ["modifier", "value", "prop", "incrementerBefore"]
@@ -102654,8 +102473,7 @@ var require_parser2 = __commonJS({
       expEdge: {
         types: {
           call: /^(\?\.)?[(]/,
-          incrementerAfter: /^(\+\+|--)/,
-          taggedTemplate: /^`(\d+)`/
+          incrementerAfter: /^(\+\+|--)/
         },
         next: ["splitter", "expEdge", "dot", "inlineIf", "expEnd"]
       },
@@ -102687,7 +102505,7 @@ var require_parser2 = __commonJS({
         types: {
           createObject: /^\{/,
           createArray: /^\[/,
-          number: /^(0b[01]+(_[01]+)*|0o[0-7]+(_[0-7]+)*|0x[\da-f]+(_[\da-f]+)*|(\d+(_\d+)*(\.\d+(_\d+)*)?|\.\d+(_\d+)*))(e[+-]?\d+(_\d+)*)?(n)?(?!\d)/i,
+          number: /^(0x[\da-f]+(_[\da-f]+)*|(\d+(_\d+)*(\.\d+(_\d+)*)?|\.\d+(_\d+)*))(e[+-]?\d+(_\d+)*)?(n)?(?!\d)/i,
           string: /^"(\d+)"/,
           literal: /^`(\d+)`/,
           regex: /^\/(\d+)\/r(?![\w$])/,
@@ -102795,8 +102613,6 @@ var require_parser2 = __commonJS({
       let isOneLiner = false;
       let i4;
       let lastInertedSemi = false;
-      let seenKeyword = false;
-      let skipNextWord = false;
       for (i4 = 0; i4 < part.length && !done; i4++) {
         let char = part.char(i4);
         if (quote === '"' || quote === "'" || quote === "`") {
@@ -102853,15 +102669,6 @@ var require_parser2 = __commonJS({
           if (foundNumber = aNumber.exec(sub)) {
             i4 += foundNumber[0].length - 1;
             sub = part.substring(i4).toString();
-            if (closingsTests) {
-              let found;
-              if (found = testMultiple(sub, closingsTests)) {
-                details.regRes = found;
-                i4++;
-                done = true;
-                break;
-              }
-            }
           } else if (lastChar != char) {
             let found = null;
             if (char === ";" || insertedSemis[i4 + part.start] && !isStart && !lastInertedSemi) {
@@ -102885,16 +102692,6 @@ var require_parser2 = __commonJS({
             }
             if (!done && (foundWord = wordReg.exec(sub))) {
               isOneLiner = true;
-              if (foundWord[2]) {
-                seenKeyword = true;
-                skipNextWord = true;
-              } else if (seenKeyword) {
-                if (skipNextWord) {
-                  skipNextWord = false;
-                } else {
-                  details.bodyContentAfterKeyword = true;
-                }
-              }
               if (foundWord[0].length > 1) {
                 details.words.push(foundWord[1]);
                 details.lastAnyWord = foundWord[1];
@@ -103004,18 +102801,10 @@ var require_parser2 = __commonJS({
             } else {
               const extract3 = restOfExp(constants, str, [/^:/]);
               key = lispify(constants, extract3, [...next, "spreadObject"]);
-              if (utils.isLisp(key) && key[0] === 17) {
-                value = NullLisp;
-              } else {
-                if (key[0] === 1) {
-                  key = key[2];
-                }
-                if (str.length > extract3.length && str.char(extract3.length) === ":") {
-                  value = lispify(constants, str.substring(extract3.length + 1));
-                } else {
-                  value = lispify(constants, extract3, next);
-                }
+              if (key[0] === 1) {
+                key = key[2];
               }
+              value = lispify(constants, str.substring(extract3.length + 1));
             }
             return createLisp({
               op: 6,
@@ -103042,72 +102831,12 @@ var require_parser2 = __commonJS({
     };
     setLispType(["inverse", "not", "negative", "positive", "typeof", "delete"], (constants, type, part, res, expect, ctx) => {
       const extract2 = restOfExp(constants, part.substring(res[0].length), [/^([^\s.?\w$]|\?[^.])/]);
-      const remainingAfterOperand = part.substring(extract2.length + res[0].length);
-      const remainingStr = remainingAfterOperand.trim().toString();
-      if (remainingStr.startsWith("**")) {
-        throw new SyntaxError("Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence");
-      }
       ctx.lispTree = lispify(constants, part.substring(extract2.length + res[0].length), restOfExp.next, createLisp({
         op: modifierTypes[type],
         a: ctx.lispTree,
         b: lispify(constants, extract2, expectTypes[expect].next)
       }));
     });
-    setLispType(["taggedTemplate"], (constants, type, part, res, expect, ctx) => {
-      const literalIndex = res[1];
-      const literal2 = constants.literals[parseInt(literalIndex)];
-      const [, templateStr, jsExprs] = literal2;
-      const stringParts = [];
-      const expressions = [];
-      let currentStr = "";
-      let i4 = 0;
-      while (i4 < templateStr.length) {
-        if (templateStr.substring(i4, i4 + 2) === "${") {
-          let j4 = i4 + 2;
-          let exprIndex = "";
-          let isValidPlaceholder = false;
-          while (j4 < templateStr.length && templateStr[j4] !== "}") {
-            exprIndex += templateStr[j4];
-            j4++;
-          }
-          if (j4 < templateStr.length && templateStr[j4] === "}" && /^\d+$/.test(exprIndex)) {
-            isValidPlaceholder = true;
-          }
-          if (isValidPlaceholder) {
-            stringParts.push(currentStr);
-            currentStr = "";
-            expressions.push(jsExprs[parseInt(exprIndex)]);
-            i4 = j4 + 1;
-          } else {
-            currentStr += templateStr[i4];
-            i4++;
-          }
-        } else {
-          currentStr += templateStr[i4];
-          i4++;
-        }
-      }
-      stringParts.push(currentStr);
-      const stringsArray = stringParts.map((str) => createLisp({
-        op: 2,
-        a: 0,
-        b: String(constants.strings.push(str) - 1)
-      }));
-      const stringsArrayLisp = createLisp({
-        op: 12,
-        a: createLisp({
-          op: 0,
-          a: 0,
-          b: 0
-        }),
-        b: stringsArray
-      });
-      ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
-        op: 5,
-        a: ctx.lispTree,
-        b: [stringsArrayLisp, ...expressions]
-      }));
-    });
     var incrementTypes = {
       "++$": 25,
       "--$": 27,
@@ -103132,7 +102861,7 @@ var require_parser2 = __commonJS({
     var adderTypes = {
       "&&": 29,
       "||": 30,
-      "??": 89,
+      "??": 85,
       instanceof: 62,
       in: 63,
       "=": 9,
@@ -103147,12 +102876,9 @@ var require_parser2 = __commonJS({
       "|=": 73,
       ">>>=": 74,
       "<<=": 76,
-      ">>=": 75,
-      "&&=": 90,
-      "||=": 91,
-      "??=": 92
+      ">>=": 75
     };
-    setLispType(["assign", "assignModify", "nullishCoalescing"], (constants, type, part, res, expect, ctx) => {
+    setLispType(["assign", "assignModify", "boolOp"], (constants, type, part, res, expect, ctx) => {
       ctx.lispTree = createLisp({
         op: adderTypes[res[0]],
         a: ctx.lispTree,
@@ -103179,46 +102905,20 @@ var require_parser2 = __commonJS({
       "/": 48,
       "**": 49,
       "*": 50,
-      "%": 51,
-      "&&": 29,
-      "||": 30,
-      instanceof: 62,
-      in: 63
-    };
-    setLispType([
-      "power",
-      "opHigh",
-      "op",
-      "comparitor",
-      "bitwiseShift",
-      "bitwiseAnd",
-      "bitwiseXor",
-      "bitwiseOr",
-      "boolOpAnd",
-      "boolOpOr"
-    ], (constants, type, part, res, expect, ctx) => {
+      "%": 51
+    };
+    setLispType(["opHigh", "op", "comparitor", "bitwise"], (constants, type, part, res, expect, ctx) => {
       const next = [expectTypes.inlineIf.types.inlineIf, inlineIfElse];
       switch (type) {
-        case "power":
-          break;
         case "opHigh":
           next.push(expectTypes.splitter.types.opHigh);
         case "op":
           next.push(expectTypes.splitter.types.op);
         case "comparitor":
           next.push(expectTypes.splitter.types.comparitor);
-        case "bitwiseShift":
-          next.push(expectTypes.splitter.types.bitwiseShift);
-        case "bitwiseAnd":
-          next.push(expectTypes.splitter.types.bitwiseAnd);
-        case "bitwiseXor":
-          next.push(expectTypes.splitter.types.bitwiseXor);
-        case "bitwiseOr":
-          next.push(expectTypes.splitter.types.bitwiseOr);
-        case "boolOpAnd":
-          next.push(expectTypes.splitter.types.boolOpAnd);
-        case "boolOpOr":
-          next.push(expectTypes.splitter.types.boolOpOr);
+        case "bitwise":
+          next.push(expectTypes.splitter.types.bitwise);
+          next.push(expectTypes.splitter.types.boolOp);
       }
       const extract2 = restOfExp(constants, part.substring(res[0].length), next);
       ctx.lispTree = lispify(constants, part.substring(extract2.length + res[0].length), restOfExp.next, createLisp({
@@ -103392,11 +103092,7 @@ var require_parser2 = __commonJS({
           prop = matches[0];
           index = prop.length + res[0].length;
         } else {
-          throw new SyntaxError("Hanging dot");
-        }
-      } else {
-        if (utils.reservedWords.has(prop) && prop !== "this") {
-          throw new SyntaxError(`Unexpected token '${prop}'`);
+          throw new SyntaxError("Hanging  dot");
         }
       }
       ctx.lispTree = lispify(constants, part.substring(index), expectTypes[expect].next, createLisp({
@@ -103421,14 +103117,14 @@ var require_parser2 = __commonJS({
     });
     setLispType(["number", "boolean", "null", "und", "NaN", "Infinity"], (constants, type, part, res, expect, ctx) => {
       ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
-        op: type === "number" ? res[12] ? 83 : 7 : 35,
+        op: type === "number" ? res[10] ? 83 : 7 : 35,
         a: 0,
-        b: res[12] ? res[1] : res[0]
+        b: res[10] ? res[1] : res[0]
       }));
     });
     setLispType(["string", "literal", "regex"], (constants, type, part, res, expect, ctx) => {
       ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
-        op: type === "string" ? 2 : type === "literal" ? 84 : 85,
+        op: type === "string" ? 2 : type === "literal" ? 84 : 86,
         a: 0,
         b: res[1]
       }));
@@ -103453,7 +103149,7 @@ var require_parser2 = __commonJS({
       const isArrow = type !== "function" && type !== "inlineFunction";
       const isReturn = isArrow && !res[res.length - 1];
       const argPos = isArrow ? 2 : 3;
-      const isAsync2 = res[1] ? 88 : 0;
+      const isAsync2 = res[1] ? 89 : 0;
       const args = res[argPos] ? res[argPos].replace(/\s+/g, "").split(/,/g) : [];
       if (!isArrow) {
         args.unshift((res[2] || "").trimStart());
@@ -103467,11 +103163,6 @@ var require_parser2 = __commonJS({
       });
       const f4 = restOfExp(constants, part.substring(res[0].length), !isReturn ? [/^}/] : [/^[,)}\]]/, semiColon]);
       const func = isReturn ? "return " + f4 : f4.toString();
-      args.forEach((arg) => {
-        if (utils.reservedWords.has(arg.replace(/^\.\.\./, ""))) {
-          throw new SyntaxError(`Unexpected token '${arg}'`);
-        }
-      });
       ctx.lispTree = lispify(constants, part.substring(res[0].length + func.length + 1), expectTypes[expect].next, createLisp({
         op: isArrow ? 11 : type === "function" ? 37 : 10,
         a: [isAsync2, ...args],
@@ -103481,13 +103172,13 @@ var require_parser2 = __commonJS({
     var iteratorRegex = /^((let|var|const)\s+)?\s*([a-zA-Z$_][a-zA-Z\d$_]*)\s+(in|of)(?![\w$])/;
     setLispType(["for", "do", "while"], (constants, type, part, res, expect, ctx) => {
       let i4 = 0;
-      let startStep = 88;
+      let startStep = 89;
       let startInternal = [];
       let getIterator = 0;
       let beforeStep = 0;
-      let checkFirst = 88;
+      let checkFirst = 89;
       let condition;
-      let step = 88;
+      let step = 89;
       let body;
       switch (type) {
         case "while": {
@@ -103567,7 +103258,7 @@ var require_parser2 = __commonJS({
     });
     setLispType(["loopAction"], (constants, type, part, res, expect, ctx) => {
       ctx.lispTree = createLisp({
-        op: 86,
+        op: 87,
         a: res[1],
         b: 0
       });
@@ -103582,7 +103273,7 @@ var require_parser2 = __commonJS({
       let offset2 = 0;
       if (catchRes[1].startsWith("catch")) {
         catchRes = catchReg.exec(part.substring(res[0].length + body.length + 1).toString());
-        exception = catchRes[3] || "";
+        exception = catchRes[2];
         catchBody = restOfExp(constants, part.substring(res[0].length + body.length + 1 + catchRes[0].length), [], "{");
         offset2 = res[0].length + body.length + 1 + catchRes[0].length + catchBody.length + 1;
         if ((catchRes = catchReg.exec(part.substring(offset2).toString())) && catchRes[1].startsWith("finally")) {
@@ -103605,7 +103296,7 @@ var require_parser2 = __commonJS({
     setLispType(["void", "await"], (constants, type, part, res, expect, ctx) => {
       const extract2 = restOfExp(constants, part.substring(res[0].length), [/^([^\s.?\w$]|\?[^.])/]);
       ctx.lispTree = lispify(constants, part.substring(res[0].length + extract2.length), expectTypes[expect].next, createLisp({
-        op: type === "void" ? 87 : 44,
+        op: type === "void" ? 88 : 44,
         a: lispify(constants, extract2),
         b: 0
       }));
@@ -103822,7 +103513,6 @@ var require_parser2 = __commonJS({
       let rest = str;
       let sub = emptyString;
       let details = {};
-      let pendingDoWhile = false;
       const inserted = insertedSemicolons.get(str.ref) || new Array(str.ref.str.length);
       while ((sub = restOfExp(constants, rest, [], void 0, void 0, [colonsRegex], details)).length) {
         let valid = false;
@@ -103837,12 +103527,7 @@ var require_parser2 = __commonJS({
             const res = closingsNoInsertion.exec(rest.substring(sub.length - 1).toString());
             if (res) {
               if (res[2] === "while") {
-                if (details.lastWord === "do") {
-                  valid = false;
-                  pendingDoWhile = true;
-                } else {
-                  valid = true;
-                }
+                valid = details.lastWord !== "do";
               } else {
                 valid = false;
               }
@@ -103850,11 +103535,8 @@ var require_parser2 = __commonJS({
               valid = false;
             }
           } else if (a4) {
-            if (pendingDoWhile && details.lastWord === "while") {
-              valid = true;
-              pendingDoWhile = false;
-            } else if (details.lastWord === "if" || details.lastWord === "while" || details.lastWord === "for" || details.lastWord === "else") {
-              valid = !!details.bodyContentAfterKeyword;
+            if (details.lastWord === "if" || details.lastWord === "while" || details.lastWord === "for" || details.lastWord === "else") {
+              valid = false;
             }
           }
         }
@@ -103916,7 +103598,6 @@ var require_parser2 = __commonJS({
               i4++;
             } else if (comment === "\n") {
               comment = "";
-              strRes.push("\n");
             }
           }
         } else {
@@ -104025,6 +103706,8 @@ var require_SandboxExec = __commonJS({
     var executor = require_executor();
     var utils = require_utils2();
     function subscribeSet(obj, name14, callback, context) {
+      if (!(obj instanceof Object))
+        throw new Error("Invalid subscription object, got " + (typeof obj === "object" ? "null" : typeof obj));
       const names = context.setSubscriptions.get(obj) || /* @__PURE__ */ new Map();
       context.setSubscriptions.set(obj, names);
       const callbacks = names.get(name14) || /* @__PURE__ */ new Set();
@@ -104050,12 +103733,6 @@ var require_SandboxExec = __commonJS({
         this.setSubscriptions = /* @__PURE__ */ new WeakMap();
         this.changeSubscriptions = /* @__PURE__ */ new WeakMap();
         this.sandboxFunctions = /* @__PURE__ */ new WeakMap();
-        this.haltSubscriptions = /* @__PURE__ */ new Set();
-        this.resumeSubscriptions = /* @__PURE__ */ new Set();
-        this.halted = false;
-        this.timeoutHandleCounter = 0;
-        this.setTimeoutHandles = /* @__PURE__ */ new Map();
-        this.setIntervalHandles = /* @__PURE__ */ new Map();
         const opt = Object.assign({
           audit: false,
           forbidFunctionCalls: false,
@@ -104068,9 +103745,7 @@ var require_SandboxExec = __commonJS({
       }
       static get SAFE_GLOBALS() {
         return {
-          globalThis,
           Function,
-          eval,
           console: {
             debug: console.debug,
             error: console.error,
@@ -104158,8 +103833,6 @@ var require_SandboxExec = __commonJS({
           map3.set(proto, /* @__PURE__ */ new Set());
         });
         map3.set(Object, /* @__PURE__ */ new Set([
-          "constructor",
-          "name",
           "entries",
           "fromEntries",
           "getOwnPropertyNames",
@@ -104185,56 +103858,20 @@ var require_SandboxExec = __commonJS({
       subscribeSetGlobal(obj, name14, callback) {
         return subscribeSet(obj, name14, callback, this);
       }
-      subscribeHalt(cb) {
-        this.haltSubscriptions.add(cb);
-        return {
-          unsubscribe: () => {
-            this.haltSubscriptions.delete(cb);
-          }
-        };
-      }
-      subscribeResume(cb) {
-        this.resumeSubscriptions.add(cb);
-        return {
-          unsubscribe: () => {
-            this.resumeSubscriptions.delete(cb);
-          }
-        };
-      }
-      haltExecution(haltContext) {
-        if (this.halted)
-          return;
-        this.halted = true;
-        for (const cb of this.haltSubscriptions) {
-          cb(haltContext);
-        }
-      }
-      resumeExecution() {
-        if (!this.halted)
-          return;
-        if (this.context.ticks.tickLimit && this.context.ticks.ticks >= this.context.ticks.tickLimit) {
-          throw new utils.SandboxExecutionQuotaExceededError("Cannot resume execution: tick limit exceeded");
-        }
-        this.halted = false;
-        for (const cb of this.resumeSubscriptions) {
-          cb();
-        }
-      }
       getContext(fn) {
         return this.sandboxFunctions.get(fn);
       }
       executeTree(context, scopes = []) {
-        return executor.executeTree(context.ctx.ticks, context, context.tree, scopes);
+        return executor.executeTree({
+          ticks: BigInt(0)
+        }, context, context.tree, scopes);
       }
       executeTreeAsync(context, scopes = []) {
-        return executor.executeTreeAsync(context.ctx.ticks, context, context.tree, scopes);
+        return executor.executeTreeAsync({
+          ticks: BigInt(0)
+        }, context, context.tree, scopes);
       }
     };
-    exports2.LocalScope = utils.LocalScope;
-    exports2.SandboxAccessError = utils.SandboxAccessError;
-    exports2.SandboxCapabilityError = utils.SandboxCapabilityError;
-    exports2.SandboxError = utils.SandboxError;
-    exports2.SandboxExecutionTreeError = utils.SandboxExecutionTreeError;
     exports2.default = SandboxExec;
   }
 });
@@ -104255,15 +103892,10 @@ var require_Sandbox = __commonJS({
         sandboxedEval,
         sandboxedSetTimeout,
         sandboxedSetInterval,
-        sandboxedClearTimeout,
-        sandboxedClearInterval,
         lispifyFunction: parser.lispifyFunction
       };
     }
-    function SB() {
-    }
     function sandboxFunction(context, ticks) {
-      SandboxFunction.prototype = SB.prototype;
       return SandboxFunction;
       function SandboxFunction(...params) {
         const code = params.pop() || "";
@@ -104275,10 +103907,7 @@ var require_Sandbox = __commonJS({
         }, void 0, "anonymous");
       }
     }
-    function SAF() {
-    }
     function sandboxAsyncFunction(context, ticks) {
-      SandboxAsyncFunction.prototype = SAF.prototype;
       return SandboxAsyncFunction;
       function SandboxAsyncFunction(...params) {
         const code = params.pop() || "";
@@ -104290,172 +103919,25 @@ var require_Sandbox = __commonJS({
         }, void 0, "anonymous");
       }
     }
-    function SE() {
-    }
-    function sandboxedEval(func, context) {
-      sandboxEval.prototype = SE.prototype;
+    function sandboxedEval(func) {
       return sandboxEval;
       function sandboxEval(code) {
-        const parsed = parser.default(code);
-        const tree = wrapLastStatementInReturn(parsed.tree);
-        return executor.createFunction([], tree, executor.currentTicks.current, {
-          ...context,
-          constants: parsed.constants,
-          tree
-        }, void 0, "anonymous")();
-      }
-    }
-    function wrapLastStatementInReturn(tree) {
-      if (tree.length === 0)
-        return tree;
-      const newTree = [...tree];
-      const lastIndex = newTree.length - 1;
-      const lastStmt = newTree[lastIndex];
-      if (Array.isArray(lastStmt) && lastStmt.length >= 1) {
-        const op2 = lastStmt[0];
-        if (op2 === 8 || op2 === 46) {
-          return newTree;
-        }
-        const statementTypes = [
-          3,
-          // 3
-          4,
-          // 4
-          34,
-          // 35
-          37,
-          // 38
-          13,
-          // 14
-          38,
-          // 39
-          39,
-          // 40
-          40,
-          // 41
-          42,
-          // 43
-          43
-          // 44
-        ];
-        if (statementTypes.includes(op2)) {
-          return newTree;
-        }
-        newTree[lastIndex] = [8, 0, lastStmt];
-      }
-      return newTree;
-    }
-    function sST() {
-    }
-    function sandboxedSetTimeout(func, context) {
-      sandboxSetTimeout.prototype = sST.prototype;
-      return sandboxSetTimeout;
-      function sandboxSetTimeout(handler, timeout, ...args) {
-        const sandbox = context.ctx.sandbox;
-        const exec6 = (...a4) => {
-          const h4 = typeof handler === "string" ? func(handler) : handler;
-          haltsub.unsubscribe();
-          contsub.unsubscribe();
-          sandbox.setTimeoutHandles.delete(sandBoxhandle);
-          return h4(...a4);
-        };
-        const sandBoxhandle = ++sandbox.timeoutHandleCounter;
-        let start = Date.now();
-        let handle = setTimeout(exec6, timeout, ...args);
-        let elapsed = 0;
-        const haltsub = sandbox.subscribeHalt(() => {
-          elapsed = Date.now() - start + elapsed;
-          clearTimeout(handle);
-        });
-        const contsub = sandbox.subscribeResume(() => {
-          start = Date.now();
-          const remaining = Math.floor((timeout || 0) - elapsed);
-          handle = setTimeout(exec6, remaining, ...args);
-          sandbox.setTimeoutHandles.set(sandBoxhandle, {
-            handle,
-            haltsub,
-            contsub
-          });
-        });
-        sandbox.setTimeoutHandles.set(sandBoxhandle, {
-          handle,
-          haltsub,
-          contsub
-        });
-        return sandBoxhandle;
-      }
-    }
-    function sCT() {
-    }
-    function sandboxedClearTimeout(context) {
-      sandboxClearTimeout.prototype = sCT.prototype;
-      return sandboxClearTimeout;
-      function sandboxClearTimeout(handle) {
-        const sandbox = context.ctx.sandbox;
-        const timeoutHandle = sandbox.setTimeoutHandles.get(handle);
-        if (timeoutHandle) {
-          clearTimeout(timeoutHandle.handle);
-          timeoutHandle.haltsub.unsubscribe();
-          timeoutHandle.contsub.unsubscribe();
-          sandbox.setTimeoutHandles.delete(handle);
-        }
+        return func(code)();
       }
     }
-    function sCI() {
-    }
-    function sandboxedClearInterval(context) {
-      sandboxClearInterval.prototype = sCI.prototype;
-      return sandboxClearInterval;
-      function sandboxClearInterval(handle) {
-        const sandbox = context.ctx.sandbox;
-        const intervalHandle = sandbox.setIntervalHandles.get(handle);
-        if (intervalHandle) {
-          clearInterval(intervalHandle.handle);
-          intervalHandle.haltsub.unsubscribe();
-          intervalHandle.contsub.unsubscribe();
-          sandbox.setIntervalHandles.delete(handle);
-        }
-      }
-    }
-    function sSI() {
+    function sandboxedSetTimeout(func) {
+      return function sandboxSetTimeout(handler, ...args) {
+        if (typeof handler !== "string")
+          return setTimeout(handler, ...args);
+        return setTimeout(func(handler), ...args);
+      };
     }
-    function sandboxedSetInterval(func, context) {
-      sandboxSetInterval.prototype = sSI.prototype;
-      return sandboxSetInterval;
-      function sandboxSetInterval(handler, timeout, ...args) {
-        const sandbox = context.ctx.sandbox;
-        const h4 = typeof handler === "string" ? func(handler) : handler;
-        const exec6 = (...a4) => {
-          start = Date.now();
-          elapsed = 0;
-          return h4(...a4);
-        };
-        const sandBoxhandle = ++sandbox.timeoutHandleCounter;
-        let start = Date.now();
-        let handle = setInterval(exec6, timeout, ...args);
-        let elapsed = 0;
-        const haltsub = sandbox.subscribeHalt(() => {
-          elapsed = Date.now() - start + elapsed;
-          clearInterval(handle);
-        });
-        const contsub = sandbox.subscribeResume(() => {
-          start = Date.now();
-          handle = setTimeout(() => {
-            start = Date.now();
-            elapsed = 0;
-            handle = setInterval(exec6, timeout, ...args);
-            exec6(...args);
-          }, Math.floor((timeout || 0) - elapsed), ...args);
-          handlObj.handle = handle;
-        });
-        const handlObj = {
-          handle,
-          haltsub,
-          contsub
-        };
-        sandbox.setIntervalHandles.set(sandBoxhandle, handlObj);
-        return sandBoxhandle;
-      }
+    function sandboxedSetInterval(func) {
+      return function sandboxSetInterval(handler, ...args) {
+        if (typeof handler !== "string")
+          return setInterval(handler, ...args);
+        return setInterval(func(handler), ...args);
+      };
     }
     var Sandbox2 = class extends SandboxExec.default {
       constructor(options) {
@@ -104514,11 +103996,6 @@ var require_Sandbox = __commonJS({
         return exec6;
       }
     };
-    exports2.LocalScope = utils.LocalScope;
-    exports2.SandboxAccessError = utils.SandboxAccessError;
-    exports2.SandboxCapabilityError = utils.SandboxCapabilityError;
-    exports2.SandboxError = utils.SandboxError;
-    exports2.SandboxExecutionTreeError = utils.SandboxExecutionTreeError;
     exports2.default = Sandbox2;
   }
 });