@cuxt/sandboxjs 0.1.1 → 0.1.4

package/dist/node/executor.js

@@ -1,1575 +0,0 @@
-'use strict';
-
-var utils = require('./utils.js');
-
-class ExecReturn {
-    constructor(auditReport, result, returned, breakLoop = false, continueLoop = false) {
-        this.auditReport = auditReport;
-        this.result = result;
-        this.returned = returned;
-        this.breakLoop = breakLoop;
-        this.continueLoop = continueLoop;
-    }
-}
-const optional = {};
-function generateArgs(argNames, args) {
-    const vars = {};
-    argNames.forEach((arg, i) => {
-        if (arg.startsWith('...')) {
-            vars[arg.substring(3)] = args.slice(i);
-        }
-        else {
-            vars[arg] = args[i];
-        }
-    });
-    return vars;
-}
-function createFunction(argNames, parsed, ticks, context, scope, name) {
-    if (context.ctx.options.forbidFunctionCreation) {
-        throw new utils.SandboxCapabilityError('Function creation is forbidden');
-    }
-    let func;
-    if (name === undefined) {
-        func = (...args) => {
-            const vars = generateArgs(argNames, args);
-            const res = executeTree(ticks, context, parsed, scope === undefined ? [] : [new utils.Scope(scope, vars)]);
-            return res.result;
-        };
-    }
-    else {
-        func = function sandboxedObject(...args) {
-            const vars = generateArgs(argNames, args);
-            const res = executeTree(ticks, context, parsed, scope === undefined ? [] : [new utils.Scope(scope, vars, this)]);
-            return res.result;
-        };
-    }
-    context.registerSandboxFunction(func);
-    context.ctx.sandboxedFunctions.add(func);
-    return func;
-}
-function createFunctionAsync(argNames, parsed, ticks, context, scope, name) {
-    if (context.ctx.options.forbidFunctionCreation) {
-        throw new utils.SandboxCapabilityError('Function creation is forbidden');
-    }
-    if (!context.ctx.prototypeWhitelist?.has(Promise.prototype)) {
-        throw new utils.SandboxCapabilityError('Async/await not permitted');
-    }
-    let func;
-    if (name === undefined) {
-        func = async (...args) => {
-            const vars = generateArgs(argNames, args);
-            const res = await executeTreeAsync(ticks, context, parsed, scope === undefined ? [] : [new utils.Scope(scope, vars)]);
-            return res.result;
-        };
-    }
-    else {
-        func = async function sandboxedObject(...args) {
-            const vars = generateArgs(argNames, args);
-            const res = await executeTreeAsync(ticks, context, parsed, scope === undefined ? [] : [new utils.Scope(scope, vars, this)]);
-            return res.result;
-        };
-    }
-    context.registerSandboxFunction(func);
-    context.ctx.sandboxedFunctions.add(func);
-    return func;
-}
-function assignCheck(obj, context, op = 'assign') {
-    if (obj.context === undefined) {
-        throw new ReferenceError(`Cannot ${op} value to undefined.`);
-    }
-    if (obj.isConst) {
-        throw new TypeError(`Assignment to constant variable.`);
-    }
-    if (obj.isGlobal) {
-        throw new utils.SandboxAccessError(`Cannot ${op} property '${obj.prop.toString()}' 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 (op === '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() }));
-        }
-    }
-    else if (utils.hasOwnProperty(obj.context, obj.prop)) {
-        context.setSubscriptions
-            .get(obj.context)
-            ?.get(obj.prop.toString())
-            ?.forEach((cb) => cb({
-            type: 'replace',
-        }));
-        context.setSubscriptionsGlobal
-            .get(obj.context)
-            ?.get(obj.prop.toString())
-            ?.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() }));
-    }
-}
-const arrayChange = new Set([
-    [].push,
-    [].pop,
-    [].shift,
-    [].unshift,
-    [].splice,
-    [].reverse,
-    [].sort,
-    [].copyWithin,
-]);
-class KeyVal {
-    constructor(key, val) {
-        this.key = key;
-        this.val = val;
-    }
-}
-class SpreadObject {
-    constructor(item) {
-        this.item = item;
-    }
-}
-class SpreadArray {
-    constructor(item) {
-        this.item = item;
-    }
-}
-class If {
-    constructor(t, f) {
-        this.t = t;
-        this.f = f;
-    }
-}
-const literalRegex = /(\$\$)*(\$)?\${(\d+)}/g;
-const ops = new Map();
-function addOps(type, cb) {
-    ops.set(type, cb);
-}
-const prorptyKeyTypes = ['string', 'number', 'symbol'];
-function isPropertyKey(val) {
-    return prorptyKeyTypes.includes(typeof val);
-}
-function hasPossibleProperties(val) {
-    return val !== null && val !== undefined;
-}
-addOps(1 /* LispType.Prop */, ({ done, a, b, obj, context, scope }) => {
-    if (a === null) {
-        throw new TypeError(`Cannot read properties of null (reading '${b?.toString()}')`);
-    }
-    if (!isPropertyKey(b)) {
-        b = `${b}`;
-    }
-    if (a === undefined && obj === undefined && typeof b === 'string') {
-        // is variable access
-        const prop = scope.get(b);
-        if (prop.context === context.ctx.sandboxGlobal) {
-            if (context.ctx.options.audit) {
-                context.ctx.auditReport?.globalsAccess.add(b);
-            }
-        }
-        const val = prop.context ? prop.context[prop.prop] : undefined;
-        const p = getGlobalProp(val, context, prop) || prop;
-        done(undefined, p);
-        return;
-    }
-    else if (a === undefined) {
-        throw new TypeError(`Cannot read properties of undefined (reading '${b.toString()}')`);
-    }
-    if (!hasPossibleProperties(a)) {
-        done(undefined, new utils.Prop(undefined, b));
-        return;
-    }
-    const prototypeAccess = typeof a === 'function' || !utils.hasOwnProperty(a, b);
-    if (context.ctx.options.audit && prototypeAccess) {
-        let prot = Object.getPrototypeOf(a);
-        do {
-            if (utils.hasOwnProperty(prot, b)) {
-                if (context.ctx.auditReport &&
-                    !context.ctx.auditReport.prototypeAccess[prot.constructor.name]) {
-                    context.ctx.auditReport.prototypeAccess[prot.constructor.name] = new Set();
-                }
-                context.ctx.auditReport?.prototypeAccess[prot.constructor.name].add(b);
-            }
-        } while ((prot = Object.getPrototypeOf(prot)));
-    }
-    if (prototypeAccess) {
-        if (typeof a === 'function') {
-            if (utils.hasOwnProperty(a, b)) {
-                const whitelist = context.ctx.prototypeWhitelist.get(a.prototype);
-                const replace = context.ctx.options.prototypeReplacements.get(a);
-                if (replace) {
-                    done(undefined, new utils.Prop(replace(a, true), b));
-                    return;
-                }
-                if (!(whitelist && (!whitelist.size || whitelist.has(b))) &&
-                    !context.ctx.sandboxedFunctions.has(a)) {
-                    throw new utils.SandboxAccessError(`Static method or property access not permitted: ${a.name}.${b.toString()}`);
-                }
-            }
-        }
-        // Fast path: check own properties of `a` first (handles static methods like Body.json)
-        if (utils.hasOwnProperty(a, b)) {
-            const replace = context.ctx.options.prototypeReplacements.get(a);
-            if (replace) {
-                done(undefined, new utils.Prop(replace(a, true), b));
-                return;
-            }
-            if (context.ctx.sandboxedFunctions.has(a)) {
-                done(undefined, new utils.Prop(a, b, false, false));
-                return;
-            }
-            // Check if constructor or any ancestor is whitelisted
-            let ctorProt = a.prototype;
-            while (ctorProt !== null) {
-                const whitelist = context.ctx.prototypeWhitelist.get(ctorProt);
-                if (whitelist && (!whitelist.size || whitelist.has(b))) {
-                    done(undefined, new utils.Prop(a, b, false, false));
-                    return;
-                }
-                ctorProt = Object.getPrototypeOf(ctorProt);
-            }
-            if (typeof a === 'function') {
-                // Constructor not whitelisted, throw
-                throw new utils.SandboxAccessError(`Method or property access not permitted: ${a.name}.${b.toString()}`);
-            }
-        }
-        let prot = a;
-        while ((prot = Object.getPrototypeOf(prot))) {
-            if (utils.hasOwnProperty(prot, b) || b === '__proto__') {
-                const replace = context.ctx.options.prototypeReplacements.get(prot.constructor);
-                if (replace) {
-                    done(undefined, new utils.Prop(replace(a, false), b));
-                    return;
-                }
-                if (context.ctx.sandboxedFunctions.has(prot.constructor)) {
-                    break;
-                }
-                // Check if this constructor or any ancestor in its prototype chain is whitelisted
-                let ctorProt = prot.constructor;
-                let whitelisted = false;
-                while (ctorProt !== null) {
-                    const whitelist = context.ctx.prototypeWhitelist.get(ctorProt);
-                    if (whitelist && (!whitelist.size || whitelist.has(b))) {
-                        whitelisted = true;
-                        break;
-                    }
-                    ctorProt = Object.getPrototypeOf(ctorProt);
-                }
-                if (whitelisted) {
-                    break;
-                }
-                if (b === '__proto__') {
-                    throw new utils.SandboxAccessError(`Access to prototype of global object is not permitted`);
-                }
-                throw new utils.SandboxAccessError(`Method or property access not permitted: ${prot.constructor.name}.${b.toString()}`);
-            }
-        }
-    }
-    const val = a[b];
-    if (typeof a === 'function') {
-        if (b === 'prototype' && !context.ctx.sandboxedFunctions.has(a)) {
-            throw new utils.SandboxAccessError(`Access to prototype of global object is not permitted`);
-        }
-    }
-    if (b === '__proto__' && !context.ctx.sandboxedFunctions.has(val?.constructor)) {
-        throw new utils.SandboxAccessError(`Access to prototype of global object is not permitted`);
-    }
-    const p = getGlobalProp(val, context, new utils.Prop(a, b, false, false));
-    if (p) {
-        done(undefined, p);
-        return;
-    }
-    const g = (obj instanceof utils.Prop && obj.isGlobal) ||
-        (typeof a === 'function' && !context.ctx.sandboxedFunctions.has(a)) ||
-        context.ctx.globalsWhitelist.has(a);
-    done(undefined, new utils.Prop(a, b, false, g, false));
-});
-function getGlobalProp(val, context, prop) {
-    if (!val)
-        return;
-    const isFunc = typeof val === 'function';
-    if (val instanceof utils.Prop) {
-        if (!prop) {
-            prop = val;
-        }
-        val = val.get(context);
-    }
-    const p = prop?.prop || 'prop';
-    if (val === globalThis) {
-        return new utils.Prop({
-            [p]: context.ctx.sandboxGlobal,
-        }, p, prop?.isConst || false, false, prop?.isVariable || false);
-    }
-    const evl = isFunc && context.evals.get(val);
-    if (evl) {
-        return new utils.Prop({
-            [p]: evl,
-        }, p, prop?.isConst || false, true, prop?.isVariable || false);
-    }
-}
-function sanitizeArray(val, context, cache = new WeakSet()) {
-    if (!Array.isArray(val))
-        return val;
-    if (cache.has(val))
-        return val;
-    cache.add(val);
-    for (let i = 0; i < val.length; i++) {
-        const item = val[i];
-        if (item === globalThis) {
-            val[i] = context.ctx.sandboxGlobal;
-        }
-        else if (typeof item === 'function') {
-            const replacement = context.evals.get(item);
-            if (replacement) {
-                val[i] = replacement;
-            }
-        }
-        else {
-            sanitizeArray(item, context, cache);
-        }
-    }
-    return val;
-}
-addOps(5 /* LispType.Call */, ({ done, a, b, obj, context }) => {
-    if (context.ctx.options.forbidFunctionCalls)
-        throw new utils.SandboxCapabilityError('Function invocations are not allowed');
-    if (typeof a !== 'function') {
-        throw new TypeError(`${typeof obj?.prop === 'symbol' ? 'Symbol' : obj?.prop} is not a function`);
-    }
-    const vals = b
-        .map((item) => {
-        if (item instanceof SpreadArray) {
-            return [...item.item];
-        }
-        else {
-            return [item];
-        }
-    })
-        .flat()
-        .map((item) => valueOrProp(item, context));
-    if (typeof obj === 'function') {
-        const evl = context.evals.get(obj);
-        let ret = evl ? evl(obj, ...vals) : obj(...vals);
-        ret = getGlobalProp(ret, context) || ret;
-        sanitizeArray(ret, context);
-        // If the function returns a Promise, await it before signaling completion.
-        // Without this, `done(undefined, promise)` resolves the outer await immediately,
-        // but the Promise itself is still pending — causing async ops to be skipped.
-        if (ret != null && typeof ret.then === 'function') {
-            ret.then((resolved) => { done(undefined, resolved); }, (err) => { done(err); });
-        }
-        else {
-            done(undefined, ret);
-        }
-        return;
-    }
-    if (obj.context[obj.prop] === JSON.stringify && context.getSubscriptions.size) {
-        const cache = new Set();
-        const recurse = (x) => {
-            if (!x || !(typeof x === 'object') || cache.has(x))
-                return;
-            cache.add(x);
-            for (const y of Object.keys(x)) {
-                context.getSubscriptions.forEach((cb) => cb(x, y));
-                recurse(x[y]);
-            }
-        };
-        recurse(vals[0]);
-    }
-    if (obj.context instanceof Array &&
-        arrayChange.has(obj.context[obj.prop]) &&
-        (context.changeSubscriptions.get(obj.context) ||
-            context.changeSubscriptionsGlobal.get(obj.context))) {
-        let change;
-        let changed = false;
-        if (obj.prop === 'push') {
-            change = {
-                type: 'push',
-                added: vals,
-            };
-            changed = !!vals.length;
-        }
-        else if (obj.prop === 'pop') {
-            change = {
-                type: 'pop',
-                removed: obj.context.slice(-1),
-            };
-            changed = !!change.removed.length;
-        }
-        else if (obj.prop === 'shift') {
-            change = {
-                type: 'shift',
-                removed: obj.context.slice(0, 1),
-            };
-            changed = !!change.removed.length;
-        }
-        else if (obj.prop === 'unshift') {
-            change = {
-                type: 'unshift',
-                added: vals,
-            };
-            changed = !!vals.length;
-        }
-        else if (obj.prop === 'splice') {
-            change = {
-                type: 'splice',
-                startIndex: vals[0],
-                deleteCount: vals[1] === undefined ? obj.context.length : vals[1],
-                added: vals.slice(2),
-                removed: obj.context.slice(vals[0], vals[1] === undefined ? undefined : vals[0] + vals[1]),
-            };
-            changed = !!change.added.length || !!change.removed.length;
-        }
-        else if (obj.prop === 'reverse' || obj.prop === 'sort') {
-            change = { type: obj.prop };
-            changed = !!obj.context.length;
-        }
-        else if (obj.prop === 'copyWithin') {
-            const len = vals[2] === undefined
-                ? obj.context.length - vals[1]
-                : Math.min(obj.context.length, vals[2] - vals[1]);
-            change = {
-                type: 'copyWithin',
-                startIndex: vals[0],
-                endIndex: vals[0] + len,
-                added: obj.context.slice(vals[1], vals[1] + len),
-                removed: obj.context.slice(vals[0], vals[0] + len),
-            };
-            changed = !!change.added.length || !!change.removed.length;
-        }
-        if (changed) {
-            context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb(change));
-            context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb(change));
-        }
-    }
-    obj.get(context);
-    const evl = context.evals.get(obj.context[obj.prop]);
-    let ret = evl ? evl(obj.context[obj.prop], ...vals) : obj.context[obj.prop](...vals);
-    ret = getGlobalProp(ret, context) || ret;
-    sanitizeArray(ret, context);
-    done(undefined, ret);
-});
-addOps(22 /* LispType.CreateObject */, ({ done, b }) => {
-    let res = {};
-    for (const item of b) {
-        if (item.key instanceof SpreadObject) {
-            res = { ...res, ...item.key.item };
-        }
-        else {
-            res[item.key] = item.val;
-        }
-    }
-    done(undefined, res);
-});
-addOps(6 /* LispType.KeyVal */, ({ done, a, b }) => done(undefined, new KeyVal(a, b)));
-addOps(12 /* LispType.CreateArray */, ({ done, b, context }) => {
-    const items = b
-        .map((item) => {
-        if (item instanceof SpreadArray) {
-            return [...item.item];
-        }
-        else {
-            return [item];
-        }
-    })
-        .flat()
-        .map((item) => valueOrProp(item, context));
-    done(undefined, items);
-});
-addOps(23 /* LispType.Group */, ({ done, b }) => done(undefined, b));
-addOps(35 /* LispType.GlobalSymbol */, ({ done, b }) => {
-    switch (b) {
-        case 'true':
-            return done(undefined, true);
-        case 'false':
-            return done(undefined, false);
-        case 'null':
-            return done(undefined, null);
-        case 'undefined':
-            return done(undefined, undefined);
-        case 'NaN':
-            return done(undefined, NaN);
-        case 'Infinity':
-            return done(undefined, Infinity);
-    }
-    done(new Error('Unknown symbol: ' + b));
-});
-addOps(7 /* LispType.Number */, ({ done, b }) => done(undefined, Number(b.replace(/_/g, ''))));
-addOps(83 /* LispType.BigInt */, ({ done, b }) => done(undefined, BigInt(b.replace(/_/g, ''))));
-addOps(2 /* LispType.StringIndex */, ({ done, b, context }) => done(undefined, context.constants.strings[parseInt(b)]));
-addOps(85 /* LispType.RegexIndex */, ({ done, b, context }) => {
-    const reg = context.constants.regexes[parseInt(b)];
-    if (!context.ctx.globalsWhitelist.has(RegExp)) {
-        throw new utils.SandboxCapabilityError('Regex not permitted');
-    }
-    else {
-        done(undefined, new RegExp(reg.regex, reg.flags));
-    }
-});
-addOps(84 /* LispType.LiteralIndex */, ({ exec, done, ticks, b, context, scope }) => {
-    const item = context.constants.literals[parseInt(b)];
-    const [, name, js] = item;
-    const found = [];
-    let f;
-    const resnums = [];
-    while ((f = literalRegex.exec(name))) {
-        if (!f[2]) {
-            found.push(js[parseInt(f[3], 10)]);
-            resnums.push(f[3]);
-        }
-    }
-    exec(ticks, found, scope, context, (...args) => {
-        const reses = {};
-        if (args.length === 1) {
-            done(args[0]);
-            return;
-        }
-        const processed = args[1];
-        for (const i of Object.keys(processed)) {
-            const num = resnums[i];
-            reses[num] = processed[i];
-        }
-        done(undefined, name.replace(/(\\\\)*(\\)?\${(\d+)}/g, (match, $$, $, num) => {
-            if ($)
-                return match;
-            const res = reses[num];
-            return ($$ ? $$ : '') + `${valueOrProp(res, context)}`;
-        }));
-    });
-});
-addOps(18 /* LispType.SpreadArray */, ({ done, b }) => {
-    done(undefined, new SpreadArray(b));
-});
-addOps(17 /* LispType.SpreadObject */, ({ done, b }) => {
-    done(undefined, new SpreadObject(b));
-});
-addOps(24 /* LispType.Not */, ({ done, b }) => done(undefined, !b));
-addOps(64 /* LispType.Inverse */, ({ done, b }) => done(undefined, ~b));
-addOps(25 /* LispType.IncrementBefore */, ({ done, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, ++obj.context[obj.prop]);
-});
-addOps(26 /* LispType.IncrementAfter */, ({ done, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, obj.context[obj.prop]++);
-});
-addOps(27 /* LispType.DecrementBefore */, ({ done, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, --obj.context[obj.prop]);
-});
-addOps(28 /* LispType.DecrementAfter */, ({ done, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, obj.context[obj.prop]--);
-});
-addOps(9 /* LispType.Assign */, ({ done, b, obj, context, scope, bobj }) => {
-    assignCheck(obj, context);
-    obj.isGlobal = bobj?.isGlobal || false;
-    if (obj.isVariable) {
-        const s = scope.getWhereValScope(obj.prop, obj.prop === 'this');
-        if (s === null) {
-            throw new ReferenceError(`Cannot assign to undeclared variable '${obj.prop.toString()}'`);
-        }
-        s.set(obj.prop, b);
-        if (obj.isGlobal) {
-            s.globals[obj.prop.toString()] = true;
-        }
-        else {
-            delete s.globals[obj.prop.toString()];
-        }
-        done(undefined, b);
-        return;
-    }
-    done(undefined, (obj.context[obj.prop] = b));
-});
-addOps(66 /* LispType.AddEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] += b));
-});
-addOps(65 /* LispType.SubractEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] -= b));
-});
-addOps(67 /* LispType.DivideEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] /= b));
-});
-addOps(69 /* LispType.MultiplyEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] *= b));
-});
-addOps(68 /* LispType.PowerEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] **= b));
-});
-addOps(70 /* LispType.ModulusEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] %= b));
-});
-addOps(71 /* LispType.BitNegateEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] ^= b));
-});
-addOps(72 /* LispType.BitAndEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] &= b));
-});
-addOps(73 /* LispType.BitOrEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] |= b));
-});
-addOps(76 /* LispType.ShiftLeftEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] <<= b));
-});
-addOps(75 /* LispType.ShiftRightEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] >>= b));
-});
-addOps(74 /* LispType.UnsignedShiftRightEquals */, ({ done, b, obj, context }) => {
-    assignCheck(obj, context);
-    done(undefined, (obj.context[obj.prop] >>>= b));
-});
-addOps(90 /* LispType.AndEquals */, ({ done, b, obj, context }) => {
-    var _a, _b;
-    assignCheck(obj, context);
-    done(undefined, ((_a = obj.context)[_b = obj.prop] && (_a[_b] = b)));
-});
-addOps(91 /* LispType.OrEquals */, ({ done, b, obj, context }) => {
-    var _a, _b;
-    assignCheck(obj, context);
-    done(undefined, ((_a = obj.context)[_b = obj.prop] || (_a[_b] = b)));
-});
-addOps(92 /* LispType.NullishCoalescingEquals */, ({ done, b, obj, context }) => {
-    var _a, _b;
-    assignCheck(obj, context);
-    done(undefined, ((_a = obj.context)[_b = obj.prop] ?? (_a[_b] = b)));
-});
-addOps(57 /* LispType.LargerThan */, ({ done, a, b }) => done(undefined, a > b));
-addOps(56 /* LispType.SmallerThan */, ({ done, a, b }) => done(undefined, a < b));
-addOps(55 /* LispType.LargerEqualThan */, ({ done, a, b }) => done(undefined, a >= b));
-addOps(54 /* LispType.SmallerEqualThan */, ({ done, a, b }) => done(undefined, a <= b));
-addOps(52 /* LispType.Equal */, ({ done, a, b }) => done(undefined, a == b));
-addOps(32 /* LispType.StrictEqual */, ({ done, a, b }) => done(undefined, a === b));
-addOps(53 /* LispType.NotEqual */, ({ done, a, b }) => done(undefined, a != b));
-addOps(31 /* LispType.StrictNotEqual */, ({ done, a, b }) => done(undefined, a !== b));
-addOps(29 /* LispType.And */, ({ done, a, b }) => done(undefined, a && b));
-addOps(30 /* LispType.Or */, ({ done, a, b }) => done(undefined, a || b));
-addOps(89 /* LispType.NullishCoalescing */, ({ done, a, b }) => done(undefined, a ?? b));
-addOps(77 /* LispType.BitAnd */, ({ done, a, b }) => done(undefined, a & b));
-addOps(78 /* LispType.BitOr */, ({ done, a, b }) => done(undefined, a | b));
-addOps(33 /* LispType.Plus */, ({ done, a, b }) => done(undefined, a + b));
-addOps(47 /* LispType.Minus */, ({ done, a, b }) => done(undefined, a - b));
-addOps(59 /* LispType.Positive */, ({ done, b }) => done(undefined, +b));
-addOps(58 /* LispType.Negative */, ({ done, b }) => done(undefined, -b));
-addOps(48 /* LispType.Divide */, ({ done, a, b }) => done(undefined, a / b));
-addOps(49 /* LispType.Power */, ({ done, a, b }) => done(undefined, a ** b));
-addOps(79 /* LispType.BitNegate */, ({ done, a, b }) => done(undefined, a ^ b));
-addOps(50 /* LispType.Multiply */, ({ done, a, b }) => done(undefined, a * b));
-addOps(51 /* LispType.Modulus */, ({ done, a, b }) => done(undefined, a % b));
-addOps(80 /* LispType.BitShiftLeft */, ({ done, a, b }) => done(undefined, a << b));
-addOps(81 /* LispType.BitShiftRight */, ({ done, a, b }) => done(undefined, a >> b));
-addOps(82 /* LispType.BitUnsignedShiftRight */, ({ done, a, b }) => done(undefined, a >>> b));
-addOps(60 /* LispType.Typeof */, ({ exec, done, ticks, b, context, scope }) => {
-    exec(ticks, b, scope, context, (e, prop) => {
-        done(undefined, typeof valueOrProp(prop, context));
-    });
-});
-addOps(62 /* LispType.Instanceof */, ({ done, a, b }) => done(undefined, a instanceof b));
-addOps(63 /* LispType.In */, ({ done, a, b }) => done(undefined, a in b));
-addOps(61 /* LispType.Delete */, ({ done, context, bobj }) => {
-    if (!(bobj instanceof utils.Prop)) {
-        done(undefined, true);
-        return;
-    }
-    assignCheck(bobj, context, 'delete');
-    if (bobj.isVariable) {
-        done(undefined, false);
-        return;
-    }
-    done(undefined, delete bobj.context?.[bobj.prop]);
-});
-addOps(8 /* LispType.Return */, ({ done, b }) => done(undefined, b));
-addOps(34 /* LispType.Var */, ({ done, a, b, scope, bobj }) => {
-    done(undefined, scope.declare(a, "var" /* VarType.var */, b, bobj?.isGlobal || false));
-});
-addOps(3 /* LispType.Let */, ({ done, a, b, scope, bobj }) => {
-    done(undefined, scope.declare(a, "let" /* VarType.let */, b, bobj?.isGlobal || false));
-});
-addOps(4 /* LispType.Const */, ({ done, a, b, scope, bobj }) => {
-    done(undefined, scope.declare(a, "const" /* VarType.const */, b, bobj?.isGlobal || false));
-});
-addOps(11 /* LispType.ArrowFunction */, ({ done, ticks, a, b, obj, context, scope }) => {
-    a = [...a];
-    if (typeof obj[2] === 'string' || obj[2] instanceof utils.CodeString) {
-        if (context.allowJit && context.evalContext) {
-            obj[2] = b = context.evalContext.lispifyFunction(new utils.CodeString(obj[2]), context.constants);
-        }
-        else {
-            throw new utils.SandboxCapabilityError('Unevaluated code detected, JIT not allowed');
-        }
-    }
-    if (a.shift()) {
-        done(undefined, createFunctionAsync(a, b, ticks, context, scope));
-    }
-    else {
-        done(undefined, createFunction(a, b, ticks, context, scope));
-    }
-});
-addOps(37 /* LispType.Function */, ({ done, ticks, a, b, obj, context, scope }) => {
-    if (typeof obj[2] === 'string' || obj[2] instanceof utils.CodeString) {
-        if (context.allowJit && context.evalContext) {
-            obj[2] = b = context.evalContext.lispifyFunction(new utils.CodeString(obj[2]), context.constants);
-        }
-        else {
-            throw new utils.SandboxCapabilityError('Unevaluated code detected, JIT not allowed');
-        }
-    }
-    const isAsync = a.shift();
-    const name = a.shift();
-    let func;
-    if (isAsync === 88 /* LispType.True */) {
-        func = createFunctionAsync(a, b, ticks, context, scope, name);
-    }
-    else {
-        func = createFunction(a, b, ticks, context, scope, name);
-    }
-    if (name) {
-        scope.declare(name, "var" /* VarType.var */, func);
-    }
-    done(undefined, func);
-});
-addOps(10 /* LispType.InlineFunction */, ({ done, ticks, a, b, obj, context, scope }) => {
-    if (typeof obj[2] === 'string' || obj[2] instanceof utils.CodeString) {
-        if (context.allowJit && context.evalContext) {
-            obj[2] = b = context.evalContext.lispifyFunction(new utils.CodeString(obj[2]), context.constants);
-        }
-        else {
-            throw new utils.SandboxCapabilityError('Unevaluated code detected, JIT not allowed');
-        }
-    }
-    const isAsync = a.shift();
-    const name = a.shift();
-    if (name) {
-        scope = new utils.Scope(scope, {});
-    }
-    let func;
-    if (isAsync === 88 /* LispType.True */) {
-        func = createFunctionAsync(a, b, ticks, context, scope, name);
-    }
-    else {
-        func = createFunction(a, b, ticks, context, scope, name);
-    }
-    if (name) {
-        scope.declare(name, "let" /* VarType.let */, func);
-    }
-    done(undefined, func);
-});
-addOps(38 /* LispType.Loop */, ({ exec, done, ticks, a, b, context, scope }) => {
-    const [checkFirst, startInternal, getIterator, startStep, step, condition, beforeStep] = a;
-    let loop = true;
-    const loopScope = new utils.Scope(scope, {});
-    const internalVars = {
-        $$obj: undefined,
-    };
-    const interalScope = new utils.Scope(loopScope, internalVars);
-    if (exec === execAsync) {
-        (async () => {
-            let ad;
-            ad = asyncDone((d) => exec(ticks, startStep, loopScope, context, d));
-            internalVars['$$obj'] =
-                (ad = asyncDone((d) => exec(ticks, getIterator, loopScope, context, d))).isInstant === true
-                    ? ad.instant
-                    : (await ad.p).result;
-            ad = asyncDone((d) => exec(ticks, startInternal, interalScope, context, d));
-            if (checkFirst)
-                loop =
-                    (ad = asyncDone((d) => exec(ticks, condition, interalScope, context, d))).isInstant ===
-                        true
-                        ? ad.instant
-                        : (await ad.p).result;
-            while (loop) {
-                const innerLoopVars = {};
-                ad = asyncDone((d) => exec(ticks, beforeStep, new utils.Scope(interalScope, innerLoopVars), context, d));
-                ad.isInstant === true ? ad.instant : (await ad.p).result;
-                const res = await executeTreeAsync(ticks, context, b, [new utils.Scope(loopScope, innerLoopVars)], 'loop');
-                if (res instanceof ExecReturn && res.returned) {
-                    done(undefined, res);
-                    return;
-                }
-                if (res instanceof ExecReturn && res.breakLoop) {
-                    break;
-                }
-                ad = asyncDone((d) => exec(ticks, step, interalScope, context, d));
-                loop =
-                    (ad = asyncDone((d) => exec(ticks, condition, interalScope, context, d))).isInstant ===
-                        true
-                        ? ad.instant
-                        : (await ad.p).result;
-            }
-            done();
-        })().catch(done);
-    }
-    else {
-        syncDone((d) => exec(ticks, startStep, loopScope, context, d));
-        internalVars['$$obj'] = syncDone((d) => exec(ticks, getIterator, loopScope, context, d)).result;
-        syncDone((d) => exec(ticks, startInternal, interalScope, context, d));
-        if (checkFirst)
-            loop = syncDone((d) => exec(ticks, condition, interalScope, context, d)).result;
-        while (loop) {
-            const innerLoopVars = {};
-            syncDone((d) => exec(ticks, beforeStep, new utils.Scope(interalScope, innerLoopVars), context, d));
-            const res = executeTree(ticks, context, b, [new utils.Scope(loopScope, innerLoopVars)], 'loop');
-            if (res instanceof ExecReturn && res.returned) {
-                done(undefined, res);
-                return;
-            }
-            if (res instanceof ExecReturn && res.breakLoop) {
-                break;
-            }
-            syncDone((d) => exec(ticks, step, interalScope, context, d));
-            loop = syncDone((d) => exec(ticks, condition, interalScope, context, d)).result;
-        }
-        done();
-    }
-});
-addOps(86 /* LispType.LoopAction */, ({ done, a, context, inLoopOrSwitch }) => {
-    if ((inLoopOrSwitch === 'switch' && a === 'continue') || !inLoopOrSwitch) {
-        throw new TypeError('Illegal ' + a + ' statement');
-    }
-    done(undefined, new ExecReturn(context.ctx.auditReport, undefined, false, a === 'break', a === 'continue'));
-});
-addOps(13 /* LispType.If */, ({ exec, done, ticks, a, b, context, scope, inLoopOrSwitch }) => {
-    exec(ticks, valueOrProp(a, context) ? b.t : b.f, scope, context, done, inLoopOrSwitch);
-});
-addOps(15 /* LispType.InlineIf */, ({ exec, done, ticks, a, b, context, scope }) => {
-    exec(ticks, valueOrProp(a, context) ? b.t : b.f, scope, context, done, undefined);
-});
-addOps(16 /* LispType.InlineIfCase */, ({ done, a, b }) => done(undefined, new If(a, b)));
-addOps(14 /* LispType.IfCase */, ({ done, a, b }) => done(undefined, new If(a, b)));
-addOps(40 /* LispType.Switch */, ({ exec, done, ticks, a, b, context, scope }) => {
-    exec(ticks, a, scope, context, (...args) => {
-        if (args.length === 1) {
-            done(args[0]);
-            return;
-        }
-        let toTest = args[1];
-        toTest = valueOrProp(toTest, context);
-        if (exec === execSync) {
-            let res;
-            let isTrue = false;
-            for (const caseItem of b) {
-                if (isTrue ||
-                    (isTrue =
-                        !caseItem[1] ||
-                            toTest ===
-                                valueOrProp(syncDone((d) => exec(ticks, caseItem[1], scope, context, d)).result, context))) {
-                    if (!caseItem[2])
-                        continue;
-                    res = executeTree(ticks, context, caseItem[2], [scope], 'switch');
-                    if (res.breakLoop)
-                        break;
-                    if (res.returned) {
-                        done(undefined, res);
-                        return;
-                    }
-                    if (!caseItem[1]) {
-                        // default case
-                        break;
-                    }
-                }
-            }
-            done();
-        }
-        else {
-            (async () => {
-                let res;
-                let isTrue = false;
-                for (const caseItem of b) {
-                    let ad;
-                    if (isTrue ||
-                        (isTrue =
-                            !caseItem[1] ||
-                                toTest ===
-                                    valueOrProp((ad = asyncDone((d) => exec(ticks, caseItem[1], scope, context, d))).isInstant ===
-                                        true
-                                        ? ad.instant
-                                        : (await ad.p).result, context))) {
-                        if (!caseItem[2])
-                            continue;
-                        res = await executeTreeAsync(ticks, context, caseItem[2], [scope], 'switch');
-                        if (res.breakLoop)
-                            break;
-                        if (res.returned) {
-                            done(undefined, res);
-                            return;
-                        }
-                        if (!caseItem[1]) {
-                            // default case
-                            break;
-                        }
-                    }
-                }
-                done();
-            })().catch(done);
-        }
-    });
-});
-addOps(39 /* LispType.Try */, ({ exec, done, ticks, a, b, context, scope, inLoopOrSwitch }) => {
-    const [exception, catchBody, finallyBody] = b;
-    // Execute try block
-    executeTreeWithDone(exec, (...tryArgs) => {
-        const tryHadError = tryArgs.length === 1;
-        const tryError = tryHadError ? tryArgs[0] : undefined;
-        const tryResult = !tryHadError && tryArgs.length > 1 ? tryArgs[1] : undefined;
-        // Handler to execute finally and complete
-        const executeFinallyAndComplete = (hadError, errorOrResult) => {
-            if (finallyBody && finallyBody.length > 0) {
-                // Execute finally block
-                executeTreeWithDone(exec, (...finallyArgs) => {
-                    const finallyHadError = finallyArgs.length === 1;
-                    const finallyResult = !finallyHadError && finallyArgs.length > 1 ? finallyArgs[1] : undefined;
-                    // If finally throws an error, it overrides everything
-                    if (finallyHadError) {
-                        done(finallyArgs[0]);
-                        return;
-                    }
-                    // If finally has a control flow statement (return/break/continue), it overrides everything
-                    if (finallyResult instanceof ExecReturn &&
-                        (finallyResult.returned || finallyResult.breakLoop || finallyResult.continueLoop)) {
-                        done(undefined, finallyResult);
-                        return;
-                    }
-                    // Otherwise, return the original try/catch result/error
-                    if (hadError) {
-                        done(errorOrResult);
-                    }
-                    else if (errorOrResult instanceof ExecReturn) {
-                        // If try/catch returned or has some other control flow, pass that through
-                        if (errorOrResult.returned ||
-                            errorOrResult.breakLoop ||
-                            errorOrResult.continueLoop) {
-                            done(undefined, errorOrResult);
-                        }
-                        else {
-                            // Normal completion - don't return a value
-                            done();
-                        }
-                    }
-                    else {
-                        // Try/catch completed normally, just signal completion with no return value
-                        done();
-                    }
-                }, ticks, context, finallyBody, [new utils.Scope(scope, {})], inLoopOrSwitch);
-            }
-            else {
-                // No finally block, just return result/error
-                if (hadError) {
-                    done(errorOrResult);
-                }
-                else if (errorOrResult instanceof ExecReturn) {
-                    // If try/catch returned or has some other control flow, pass that through
-                    if (errorOrResult.returned || errorOrResult.breakLoop || errorOrResult.continueLoop) {
-                        done(undefined, errorOrResult);
-                    }
-                    else {
-                        // Normal completion - don't return a value
-                        done();
-                    }
-                }
-                else {
-                    done();
-                }
-            }
-        };
-        // If try had an error and there's a catch block, execute catch
-        if (tryHadError && catchBody && catchBody.length > 0) {
-            const sc = {};
-            if (exception)
-                sc[exception] = tryError;
-            executeTreeWithDone(exec, (...catchArgs) => {
-                const catchHadError = catchArgs.length === 1;
-                const catchErrorOrResult = catchHadError
-                    ? catchArgs[0]
-                    : catchArgs.length > 1
-                        ? catchArgs[1]
-                        : undefined;
-                // Execute finally with catch result
-                executeFinallyAndComplete(catchHadError, catchErrorOrResult);
-            }, ticks, context, catchBody, [new utils.Scope(scope, sc)], inLoopOrSwitch);
-        }
-        else {
-            // No catch or no error, execute finally with try result
-            executeFinallyAndComplete(tryHadError, tryHadError ? tryError : tryResult);
-        }
-    }, ticks, context, a, [new utils.Scope(scope)], inLoopOrSwitch);
-});
-addOps(87 /* LispType.Void */, ({ done }) => {
-    done();
-});
-addOps(45 /* LispType.New */, ({ done, a, b, context }) => {
-    if (!context.ctx.globalsWhitelist.has(a) && !context.ctx.sandboxedFunctions.has(a)) {
-        throw new utils.SandboxAccessError(`Object construction not allowed: ${a.constructor.name}`);
-    }
-    done(undefined, new a(...b));
-});
-addOps(46 /* LispType.Throw */, ({ done, b }) => {
-    done(b);
-});
-addOps(43 /* LispType.Expression */, ({ done, a }) => done(undefined, a.pop()));
-addOps(0 /* LispType.None */, ({ done }) => done());
-function valueOrProp(a, context) {
-    if (a instanceof utils.Prop)
-        return a.get(context);
-    if (a === optional)
-        return undefined;
-    return a;
-}
-function execMany(ticks, exec, tree, done, scope, context, inLoopOrSwitch) {
-    if (exec === execSync) {
-        _execManySync(ticks, tree, done, scope, context, inLoopOrSwitch);
-    }
-    else {
-        _execManyAsync(ticks, tree, done, scope, context, inLoopOrSwitch).catch(done);
-    }
-}
-function _execManySync(ticks, tree, done, scope, context, inLoopOrSwitch) {
-    const ret = [];
-    for (let i = 0; i < tree.length; i++) {
-        let res = syncDone((d) => execSync(ticks, tree[i], scope, context, d, inLoopOrSwitch)).result;
-        if (res instanceof ExecReturn && (res.returned || res.breakLoop || res.continueLoop)) {
-            done(undefined, res);
-            return;
-        }
-        if (utils.isLisp(tree[i]) && tree[i][0] === 8 /* LispType.Return */) {
-            done(undefined, new ExecReturn(context.ctx.auditReport, res, true));
-            return;
-        }
-        ret.push(res);
-    }
-    done(undefined, ret);
-}
-async function _execManyAsync(ticks, tree, done, scope, context, inLoopOrSwitch) {
-    const ret = [];
-    for (let i = 0; i < tree.length; i++) {
-        let res;
-        try {
-            let ad;
-            res =
-                (ad = asyncDone((d) => execAsync(ticks, tree[i], scope, context, d, inLoopOrSwitch)))
-                    .isInstant === true
-                    ? ad.instant
-                    : (await ad.p).result;
-        }
-        catch (e) {
-            done(e);
-            return;
-        }
-        if (res instanceof ExecReturn && (res.returned || res.breakLoop || res.continueLoop)) {
-            done(undefined, res);
-            return;
-        }
-        if (utils.isLisp(tree[i]) && tree[i][0] === 8 /* LispType.Return */) {
-            done(undefined, new ExecReturn(context.ctx.auditReport, res, true));
-            return;
-        }
-        ret.push(res);
-    }
-    done(undefined, ret);
-}
-function asyncDone(callback) {
-    let isInstant = false;
-    let instant;
-    const p = new Promise((resolve, reject) => {
-        callback((...args) => {
-            if (args.length === 1)
-                reject(args[0]);
-            else {
-                isInstant = true;
-                instant = args[1];
-                resolve({ result: args[1] });
-            }
-        });
-    });
-    return {
-        isInstant,
-        instant,
-        p,
-    };
-}
-function syncDone(callback) {
-    let result;
-    let err;
-    callback((...args) => {
-        err = args.length === 1 ? { error: args[0] } : undefined;
-        result = args[1];
-    });
-    if (err)
-        throw err.error;
-    return { result };
-}
-async function execAsync(ticks, tree, scope, context, doneOriginal, inLoopOrSwitch) {
-    let done = doneOriginal;
-    const p = new Promise((resolve) => {
-        done = (...args) => {
-            doneOriginal(...args);
-            resolve();
-        };
-    });
-    if (!_execNoneRecurse(ticks, tree, scope, context, done, true, inLoopOrSwitch) && utils.isLisp(tree)) {
-        let op = tree[0];
-        let obj;
-        try {
-            let ad;
-            obj =
-                (ad = asyncDone((d) => execAsync(ticks, tree[1], scope, context, d, inLoopOrSwitch)))
-                    .isInstant === true
-                    ? ad.instant
-                    : (await ad.p).result;
-        }
-        catch (e) {
-            done(e);
-            return;
-        }
-        let a = obj;
-        try {
-            a = obj instanceof utils.Prop ? obj.get(context) : obj;
-        }
-        catch (e) {
-            done(e);
-            return;
-        }
-        if (op === 20 /* LispType.PropOptional */ || op === 21 /* LispType.CallOptional */) {
-            if (a === undefined || a === null) {
-                done(undefined, optional);
-                return;
-            }
-            op = op === 20 /* LispType.PropOptional */ ? 1 /* LispType.Prop */ : 5 /* LispType.Call */;
-        }
-        if (a === optional) {
-            if (op === 1 /* LispType.Prop */ || op === 5 /* LispType.Call */) {
-                done(undefined, a);
-                return;
-            }
-            else {
-                a = undefined;
-            }
-        }
-        // Short-circuit for nullish coalescing: if a is not null/undefined, return a without evaluating b
-        if (op === 89 /* LispType.NullishCoalescing */ && a !== undefined && a !== null) {
-            done(undefined, a);
-            return;
-        }
-        let bobj;
-        try {
-            let ad;
-            bobj =
-                (ad = asyncDone((d) => execAsync(ticks, tree[2], scope, context, d, inLoopOrSwitch)))
-                    .isInstant === true
-                    ? ad.instant
-                    : (await ad.p).result;
-        }
-        catch (e) {
-            done(e);
-            return;
-        }
-        let b = bobj;
-        try {
-            b = bobj instanceof utils.Prop ? bobj.get(context) : bobj;
-        }
-        catch (e) {
-            done(e);
-            return;
-        }
-        if (b === optional) {
-            b = undefined;
-        }
-        performOp({
-            op,
-            exec: execAsync,
-            done,
-            ticks,
-            a,
-            b,
-            obj,
-            context,
-            scope,
-            bobj,
-            inLoopOrSwitch,
-            tree,
-        });
-    }
-    await p;
-}
-function execSync(ticks, tree, scope, context, done, inLoopOrSwitch) {
-    if (!_execNoneRecurse(ticks, tree, scope, context, done, false, inLoopOrSwitch) && utils.isLisp(tree)) {
-        let op = tree[0];
-        let obj = syncDone((d) => execSync(ticks, tree[1], scope, context, d, inLoopOrSwitch)).result;
-        let a = obj instanceof utils.Prop ? obj.get(context) : obj;
-        if (op === 20 /* LispType.PropOptional */ || op === 21 /* LispType.CallOptional */) {
-            if (a === undefined || a === null) {
-                done(undefined, optional);
-                return;
-            }
-            op = op === 20 /* LispType.PropOptional */ ? 1 /* LispType.Prop */ : 5 /* LispType.Call */;
-        }
-        if (a === optional) {
-            if (op === 1 /* LispType.Prop */ || op === 5 /* LispType.Call */) {
-                done(undefined, a);
-                return;
-            }
-            else {
-                a = undefined;
-            }
-        }
-        // Short-circuit for nullish coalescing: if a is not null/undefined, return a without evaluating b
-        if (op === 89 /* LispType.NullishCoalescing */ && a !== undefined && a !== null) {
-            done(undefined, a);
-            return;
-        }
-        let bobj = syncDone((d) => execSync(ticks, tree[2], scope, context, d, inLoopOrSwitch)).result;
-        let b = bobj instanceof utils.Prop ? bobj.get(context) : bobj;
-        if (b === optional) {
-            b = undefined;
-        }
-        performOp({
-            op,
-            exec: execSync,
-            done,
-            ticks,
-            a,
-            b,
-            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 } = params;
-    if (sandbox.halted) {
-        const sub = sandbox.subscribeResume(() => {
-            sub.unsubscribe();
-            try {
-                const o = ops.get(op);
-                if (!o) {
-                    done(new SyntaxError('Unknown operator: ' + op));
-                    return;
-                }
-                o(params);
-            }
-            catch (err) {
-                if (options.haltOnSandboxError && err instanceof utils.SandboxError) {
-                    const sub = sandbox.subscribeResume(() => {
-                        sub.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 o = ops.get(op);
-                if (!o) {
-                    done(new SyntaxError('Unknown operator: ' + op));
-                    return;
-                }
-                o(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);
-                }
-            }
-        });
-        const error = new utils.SandboxExecutionQuotaExceededError('Execution quota exceeded');
-        sandbox.haltExecution({
-            error,
-            ticks,
-            scope: scope,
-            context,
-        });
-        return true;
-    }
-    return false;
-}
-function performOp(params) {
-    const { done, op, ticks, context, scope } = params;
-    ticks.ticks++;
-    const sandbox = context.ctx.sandbox;
-    if (checkHaltExpectedTicks(params)) {
-        return;
-    }
-    try {
-        const o = ops.get(op);
-        if (!o) {
-            done(new utils.SandboxExecutionTreeError('Unknown operator: ' + op));
-            return;
-        }
-        o(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);
-        }
-    }
-}
-const unexecTypes = new Set([
-    11 /* LispType.ArrowFunction */,
-    37 /* LispType.Function */,
-    10 /* LispType.InlineFunction */,
-    38 /* LispType.Loop */,
-    39 /* LispType.Try */,
-    40 /* LispType.Switch */,
-    14 /* LispType.IfCase */,
-    16 /* LispType.InlineIfCase */,
-    60 /* LispType.Typeof */,
-]);
-function _execNoneRecurse(ticks, tree, scope, context, done, isAsync, inLoopOrSwitch) {
-    const exec = isAsync ? execAsync : execSync;
-    if (tree instanceof utils.Prop) {
-        done(undefined, tree.get(context));
-    }
-    else if (tree === optional) {
-        done();
-    }
-    else if (Array.isArray(tree) && !utils.isLisp(tree)) {
-        if (tree[0] === 0 /* LispType.None */) {
-            done();
-        }
-        else {
-            execMany(ticks, exec, tree, done, scope, context, inLoopOrSwitch);
-        }
-    }
-    else if (!utils.isLisp(tree)) {
-        done(undefined, tree);
-    }
-    else if (tree[0] === 42 /* LispType.Block */) {
-        execMany(ticks, exec, tree[1], done, scope, context, inLoopOrSwitch);
-    }
-    else if (tree[0] === 44 /* LispType.Await */) {
-        if (!isAsync) {
-            done(new SyntaxError("Illegal use of 'await', must be inside async function"));
-        }
-        else if (context.ctx.prototypeWhitelist?.has(Promise.prototype)) {
-            execAsync(ticks, tree[1], scope, context, async (...args) => {
-                if (args.length === 1)
-                    done(args[0]);
-                else
-                    try {
-                        done(undefined, (await valueOrProp(args[1], context)));
-                    }
-                    catch (err) {
-                        done(err);
-                    }
-            }, inLoopOrSwitch).catch(done);
-        }
-        else {
-            done(new utils.SandboxCapabilityError('Async/await is not permitted'));
-        }
-    }
-    else if (unexecTypes.has(tree[0])) {
-        performOp({
-            op: tree[0],
-            exec,
-            done,
-            ticks,
-            a: tree[1],
-            b: tree[2],
-            obj: tree,
-            tree,
-            context,
-            scope,
-            bobj: undefined,
-            inLoopOrSwitch,
-        });
-    }
-    else {
-        return false;
-    }
-    return true;
-}
-function executeTree(ticks, context, executionTree, scopes = [], inLoopOrSwitch) {
-    return syncDone((done) => executeTreeWithDone(execSync, done, ticks, context, executionTree, scopes, inLoopOrSwitch)).result;
-}
-async function executeTreeAsync(ticks, context, executionTree, scopes = [], inLoopOrSwitch) {
-    let ad;
-    return (ad = asyncDone((done) => executeTreeWithDone(execAsync, done, ticks, context, executionTree, scopes, inLoopOrSwitch))).isInstant === true
-        ? ad.instant
-        : (await ad.p).result;
-}
-function executeTreeWithDone(exec, done, ticks, context, executionTree, scopes = [], inLoopOrSwitch) {
-    if (!executionTree) {
-        done();
-        return;
-    }
-    if (!(executionTree instanceof Array)) {
-        throw new SyntaxError('Bad execution tree');
-    }
-    let scope = context.ctx.globalScope;
-    let s;
-    while ((s = scopes.shift())) {
-        if (typeof s !== 'object')
-            continue;
-        if (s instanceof utils.Scope) {
-            scope = s;
-        }
-        else {
-            scope = new utils.Scope(scope, s, s instanceof utils.LocalScope ? undefined : null);
-        }
-    }
-    if (context.ctx.options.audit && !context.ctx.auditReport) {
-        context.ctx.auditReport = {
-            globalsAccess: new Set(),
-            prototypeAccess: {},
-        };
-    }
-    if (exec === execSync) {
-        _executeWithDoneSync(done, ticks, context, executionTree, scope, inLoopOrSwitch);
-    }
-    else {
-        _executeWithDoneAsync(done, ticks, context, executionTree, scope, inLoopOrSwitch).catch(done);
-    }
-}
-function _executeWithDoneSync(done, ticks, context, executionTree, scope, inLoopOrSwitch) {
-    if (!(executionTree instanceof Array))
-        throw new SyntaxError('Bad execution tree');
-    let i = 0;
-    for (i = 0; i < executionTree.length; i++) {
-        let res;
-        let err;
-        const current = executionTree[i];
-        try {
-            execSync(ticks, current, scope, context, (...args) => {
-                if (args.length === 1)
-                    err = { error: args[0] };
-                else
-                    res = args[1];
-            }, inLoopOrSwitch);
-        }
-        catch (e) {
-            err = { error: e };
-        }
-        if (err) {
-            done(err.error);
-            return;
-        }
-        if (res instanceof ExecReturn) {
-            done(undefined, res);
-            return;
-        }
-        if (utils.isLisp(current) && current[0] === 8 /* LispType.Return */) {
-            done(undefined, new ExecReturn(context.ctx.auditReport, res, true));
-            return;
-        }
-    }
-    done(undefined, new ExecReturn(context.ctx.auditReport, undefined, false));
-}
-async function _executeWithDoneAsync(done, ticks, context, executionTree, scope, inLoopOrSwitch) {
-    if (!(executionTree instanceof Array))
-        throw new SyntaxError('Bad execution tree');
-    let i = 0;
-    for (i = 0; i < executionTree.length; i++) {
-        let res;
-        let err;
-        const current = executionTree[i];
-        try {
-            await execAsync(ticks, current, scope, context, (...args) => {
-                if (args.length === 1)
-                    err = { error: args[0] };
-                else
-                    res = args[1];
-            }, inLoopOrSwitch);
-        }
-        catch (e) {
-            err = { error: e };
-        }
-        if (err) {
-            done(err.error);
-            return;
-        }
-        if (res instanceof ExecReturn) {
-            done(undefined, res);
-            return;
-        }
-        if (utils.isLisp(current) && current[0] === 8 /* LispType.Return */) {
-            done(undefined, new ExecReturn(context.ctx.auditReport, res, true));
-            return;
-        }
-    }
-    done(undefined, new ExecReturn(context.ctx.auditReport, undefined, false));
-}
-
-exports.ExecReturn = ExecReturn;
-exports.If = If;
-exports.KeyVal = KeyVal;
-exports.SpreadArray = SpreadArray;
-exports.SpreadObject = SpreadObject;
-exports.addOps = addOps;
-exports.assignCheck = assignCheck;
-exports.asyncDone = asyncDone;
-exports.createFunction = createFunction;
-exports.createFunctionAsync = createFunctionAsync;
-exports.execAsync = execAsync;
-exports.execMany = execMany;
-exports.execSync = execSync;
-exports.executeTree = executeTree;
-exports.executeTreeAsync = executeTreeAsync;
-exports.ops = ops;
-exports.syncDone = syncDone;