@cuxt/sandboxjs 0.1.1 → 0.1.4

package/dist/cjs/executor/index.d.ts

@@ -0,0 +1 @@
+export * from './executorUtils';

package/dist/cjs/executor/index.js

@@ -0,0 +1,2 @@
+require("./opsRegistry.js");
+require("./executorUtils.js");

package/dist/cjs/executor/ops/assignment.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/assignment.js

@@ -0,0 +1,88 @@
+const require_types = require("../../utils/types.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/assignment.ts
+require_opsRegistry.addOps(require_types.LispType.Assign, (params) => {
+	const { done, b, obj, context, scope, bobj, internal } = params;
+	require_executorUtils.assignCheck(obj, context);
+	obj.isGlobal = bobj?.isGlobal || false;
+	if (obj.isVariable) {
+		const s = scope.getWhereValScope(obj.prop, obj.prop === "this", internal);
+		if (s === null) throw new ReferenceError(`Cannot assign to undeclared variable '${obj.prop.toString()}'`);
+		s.set(obj.prop, b, internal);
+		if (obj.isGlobal) s.globals[obj.prop.toString()] = true;
+		else delete s.globals[obj.prop.toString()];
+		done(void 0, b);
+		return;
+	}
+	if (obj.prop === "length" && Array.isArray(obj.context) && typeof b === "number") {
+		const delta = BigInt(Math.abs(b - obj.context.length));
+		if (delta > 0n && require_executorUtils.checkHaltExpectedTicks(params, delta)) return;
+	}
+	done(void 0, obj.context[obj.prop] = b);
+});
+require_opsRegistry.addOps(require_types.LispType.AddEquals, (params) => {
+	const { done, b, obj, context } = params;
+	require_executorUtils.assignCheck(obj, context);
+	const result = obj.context[obj.prop] + b;
+	if (typeof result === "string" && require_executorUtils.checkHaltExpectedTicks(params, BigInt(result.length))) return;
+	done(void 0, obj.context[obj.prop] = result);
+});
+require_opsRegistry.addOps(require_types.LispType.SubractEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] -= b);
+});
+require_opsRegistry.addOps(require_types.LispType.DivideEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] /= b);
+});
+require_opsRegistry.addOps(require_types.LispType.MultiplyEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] *= b);
+});
+require_opsRegistry.addOps(require_types.LispType.PowerEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] **= b);
+});
+require_opsRegistry.addOps(require_types.LispType.ModulusEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] %= b);
+});
+require_opsRegistry.addOps(require_types.LispType.BitNegateEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] ^= b);
+});
+require_opsRegistry.addOps(require_types.LispType.BitAndEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] &= b);
+});
+require_opsRegistry.addOps(require_types.LispType.BitOrEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] |= b);
+});
+require_opsRegistry.addOps(require_types.LispType.ShiftLeftEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] <<= b);
+});
+require_opsRegistry.addOps(require_types.LispType.ShiftRightEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] >>= b);
+});
+require_opsRegistry.addOps(require_types.LispType.UnsignedShiftRightEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] >>>= b);
+});
+require_opsRegistry.addOps(require_types.LispType.AndEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] &&= b);
+});
+require_opsRegistry.addOps(require_types.LispType.OrEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] ||= b);
+});
+require_opsRegistry.addOps(require_types.LispType.NullishCoalescingEquals, ({ done, b, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop] ??= b);
+});
+//#endregion

package/dist/cjs/executor/ops/call.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/call.js

@@ -0,0 +1,160 @@
+const require_errors = require("../../utils/errors.js");
+const require_types = require("../../utils/types.js");
+const require_functionReplacements = require("../../utils/functionReplacements.js");
+const require_Prop = require("../../utils/Prop.js");
+const require_Scope = require("../../utils/Scope.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/call.ts
+require_opsRegistry.addOps(require_types.LispType.Call, (params) => {
+	const { done, a, b, obj, context } = params;
+	if (context.ctx.options.forbidFunctionCalls) throw new require_errors.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 = new Array(b.length);
+	let valsLen = 0;
+	for (let i = 0; i < b.length; i++) {
+		const item = b[i];
+		if (item instanceof require_executorUtils.SpreadArray) {
+			const expanded = Array.isArray(item.item) ? item.item : [...item.item];
+			if (require_executorUtils.checkHaltExpectedTicks(params, BigInt(expanded.length))) return;
+			for (let j = 0; j < expanded.length; j++) vals[valsLen++] = require_Scope.sanitizeProp(expanded[j], context);
+		} else vals[valsLen++] = require_Scope.sanitizeProp(item, context);
+	}
+	vals.length = valsLen;
+	if (a === String) {
+		const result = String(vals[0]);
+		require_functionReplacements.checkTicksAndThrow(context, BigInt(result.length));
+		done(void 0, result);
+		return;
+	}
+	if (typeof obj === "function") {
+		const evl = context.evals.get(obj);
+		const receiver = require_Prop.getReplacementReceiver(obj);
+		let ret = evl ? evl(obj, ...vals) : receiver === void 0 ? obj(...vals) : obj.call(receiver, ...vals);
+		ret = require_Scope.sanitizeProp(ret, context);
+		if (ret !== null && typeof ret === "object" && ret instanceof require_Scope.DelayedSynchronousResult) Promise.resolve(ret.result).then((res) => done(void 0, res), (err) => done(err));
+		else done(void 0, ret);
+		return;
+	}
+	const originalFn = obj.context[obj.prop];
+	if (originalFn === JSON.stringify && context.getSubscriptions.size) {
+		const cache = /* @__PURE__ */ new WeakSet();
+		let ticks = 0n;
+		const recurse = (x) => {
+			if (!x || !(typeof x === "object") || cache.has(x)) return;
+			cache.add(x);
+			const keys = Object.keys(x);
+			ticks += BigInt(keys.length);
+			for (const y of keys) {
+				context.getSubscriptions.forEach((cb) => cb(x, y));
+				recurse(x[y]);
+			}
+		};
+		recurse(vals[0]);
+		require_functionReplacements.checkTicksAndThrow(context, ticks);
+	}
+	if (obj.context instanceof Array && require_executorUtils.arrayChange.has(originalFn) && (context.changeSubscriptions.get(obj.context) || context.changeSubscriptionsGlobal.get(obj.context))) {
+		let change = void 0;
+		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] === void 0 ? obj.context.length : vals[1],
+				added: vals.slice(2),
+				removed: obj.context.slice(vals[0], vals[1] === void 0 ? void 0 : 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] === void 0 ? 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) {
+			const subs = context.changeSubscriptions.get(obj.context);
+			if (subs !== void 0) for (const cb of subs) cb(change);
+			const subsG = context.changeSubscriptionsGlobal.get(obj.context);
+			if (subsG !== void 0) for (const cb of subsG) cb(change);
+		}
+	}
+	obj.get(context);
+	const evl = context.evals.get(originalFn);
+	const receiver = require_Prop.getReplacementReceiver(originalFn);
+	const thisArg = obj.isVariable && receiver !== void 0 ? receiver : obj.context;
+	let ret = evl ? evl.call(thisArg, ...vals) : a.call(thisArg, ...vals);
+	ret = require_Scope.sanitizeProp(ret, context);
+	if (ret !== null && typeof ret === "object" && ret instanceof require_Scope.DelayedSynchronousResult) Promise.resolve(ret.result).then((res) => done(void 0, res), (err) => done(err));
+	else done(void 0, ret);
+});
+require_opsRegistry.addOps(require_types.LispType.New, (params) => {
+	const { done, a, b, context } = params;
+	if (!context.ctx.globalsWhitelist.has(a) && !context.ctx.sandboxedFunctions.has(a)) throw new require_errors.SandboxAccessError(`Object construction not allowed: ${a.constructor.name}`);
+	const vals = b.map((item) => require_Scope.sanitizeProp(item, context));
+	const replacement = context.evals.get(a);
+	if (replacement) {
+		done(void 0, new replacement(...vals));
+		return;
+	}
+	const expectedTicks = getNewTicks(a, vals);
+	if (expectedTicks > 0n && require_executorUtils.checkHaltExpectedTicks(params, expectedTicks)) return;
+	done(void 0, new a(...vals));
+});
+function getNewTicks(ctor, args) {
+	if (ctor === Array) {
+		const n = args[0];
+		if (typeof n === "number" && args.length === 1) return BigInt(n);
+		return BigInt(args.length);
+	}
+	if (require_functionReplacements.typedArrayProtos.has(Object.getPrototypeOf(ctor.prototype))) {
+		const n = args[0];
+		if (typeof n === "number") return BigInt(n);
+		if (Array.isArray(n) || ArrayBuffer.isView(n)) return BigInt(n.length);
+		return 0n;
+	}
+	if (ctor === Map || ctor === Set) {
+		const iterable = args[0];
+		if (Array.isArray(iterable)) return BigInt(iterable.length);
+		return 0n;
+	}
+	if (ctor === String || ctor === RegExp) {
+		const s = args[0];
+		if (typeof s === "string") return BigInt(s.length);
+		return 0n;
+	}
+	return 0n;
+}
+//#endregion

package/dist/cjs/executor/ops/comparison.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/comparison.js

@@ -0,0 +1,36 @@
+const require_types = require("../../utils/types.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/comparison.ts
+require_opsRegistry.addOps(require_types.LispType.LargerThan, ({ done, a, b }) => done(void 0, a > b));
+require_opsRegistry.addOps(require_types.LispType.SmallerThan, ({ done, a, b }) => done(void 0, a < b));
+require_opsRegistry.addOps(require_types.LispType.LargerEqualThan, ({ done, a, b }) => done(void 0, a >= b));
+require_opsRegistry.addOps(require_types.LispType.SmallerEqualThan, ({ done, a, b }) => done(void 0, a <= b));
+require_opsRegistry.addOps(require_types.LispType.Equal, ({ done, a, b }) => done(void 0, a == b));
+require_opsRegistry.addOps(require_types.LispType.StrictEqual, ({ done, a, b }) => done(void 0, a === b));
+require_opsRegistry.addOps(require_types.LispType.NotEqual, ({ done, a, b }) => done(void 0, a != b));
+require_opsRegistry.addOps(require_types.LispType.StrictNotEqual, ({ done, a, b }) => done(void 0, a !== b));
+require_opsRegistry.addOps(require_types.LispType.And, ({ done, a, b }) => done(void 0, a && b));
+require_opsRegistry.addOps(require_types.LispType.Or, ({ done, a, b }) => done(void 0, a || b));
+require_opsRegistry.addOps(require_types.LispType.NullishCoalescing, ({ done, a, b }) => done(void 0, a ?? b));
+require_opsRegistry.addOps(require_types.LispType.BitAnd, ({ done, a, b }) => done(void 0, a & b));
+require_opsRegistry.addOps(require_types.LispType.BitOr, ({ done, a, b }) => done(void 0, a | b));
+require_opsRegistry.addOps(require_types.LispType.Plus, (params) => {
+	const { done, a, b } = params;
+	const result = a + b;
+	if (typeof result === "string" && require_executorUtils.checkHaltExpectedTicks(params, BigInt(result.length))) return;
+	done(void 0, result);
+});
+require_opsRegistry.addOps(require_types.LispType.Minus, ({ done, a, b }) => done(void 0, a - b));
+require_opsRegistry.addOps(require_types.LispType.Divide, ({ done, a, b }) => done(void 0, a / b));
+require_opsRegistry.addOps(require_types.LispType.Power, ({ done, a, b }) => done(void 0, a ** b));
+require_opsRegistry.addOps(require_types.LispType.BitNegate, ({ done, a, b }) => done(void 0, a ^ b));
+require_opsRegistry.addOps(require_types.LispType.Multiply, ({ done, a, b }) => done(void 0, a * b));
+require_opsRegistry.addOps(require_types.LispType.Modulus, ({ done, a, b }) => done(void 0, a % b));
+require_opsRegistry.addOps(require_types.LispType.BitShiftLeft, ({ done, a, b }) => done(void 0, a << b));
+require_opsRegistry.addOps(require_types.LispType.BitShiftRight, ({ done, a, b }) => done(void 0, a >> b));
+require_opsRegistry.addOps(require_types.LispType.BitUnsignedShiftRight, ({ done, a, b }) => done(void 0, a >>> b));
+require_opsRegistry.addOps(require_types.LispType.Instanceof, ({ done, a, b }) => done(void 0, a instanceof b));
+require_opsRegistry.addOps(require_types.LispType.In, ({ done, a, b }) => done(void 0, a in b));
+//#endregion

package/dist/cjs/executor/ops/control.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/control.js

@@ -0,0 +1,203 @@
+const require_errors = require("../../utils/errors.js");
+const require_types = require("../../utils/types.js");
+const require_Scope = require("../../utils/Scope.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/control.ts
+require_opsRegistry.addOps(require_types.LispType.Loop, ({ exec, done, ticks, a, b, context, scope, statementLabels, internal, generatorYield }) => {
+	const [checkFirst, startInternal, getIterator, startStep, step, condition, beforeStep, isForAwait, label] = a;
+	const loopStatementTargets = [...require_executorUtils.normalizeStatementLabels(label).map((loopLabel) => require_executorUtils.createLoopTarget(loopLabel, false)), require_executorUtils.createLoopTarget()];
+	const loopTargets = require_executorUtils.addControlFlowTargets(statementLabels, loopStatementTargets);
+	if (isForAwait === require_types.LispType.True && exec !== require_executorUtils.execAsync) {
+		done(/* @__PURE__ */ new SyntaxError("for-await-of loops are only allowed inside async functions"));
+		return;
+	}
+	let loop = true;
+	const loopScope = new require_Scope.Scope(scope, {});
+	const internalVars = { $$obj: void 0 };
+	const interalScope = new require_Scope.Scope(loopScope, internalVars);
+	if (exec === require_executorUtils.execAsync) (async () => {
+		let ad;
+		ad = require_executorUtils.asyncDone((d) => exec(ticks, startStep, loopScope, context, d, void 0, internal, generatorYield));
+		internalVars["$$obj"] = (ad = require_executorUtils.asyncDone((d) => exec(ticks, getIterator, loopScope, context, d, void 0, internal, generatorYield))).isInstant === true ? ad.instant : (await ad.p).result;
+		if (isForAwait === require_types.LispType.True) {
+			const obj = internalVars["$$obj"];
+			internalVars["$$obj"] = obj[Symbol.asyncIterator] ? obj[Symbol.asyncIterator]() : obj[Symbol.iterator] ? obj[Symbol.iterator]() : obj;
+		}
+		ad = require_executorUtils.asyncDone((d) => exec(ticks, startInternal, interalScope, context, d, void 0, internal, generatorYield));
+		if (isForAwait === require_types.LispType.True) internalVars["$$next"] = await internalVars["$$next"];
+		if (checkFirst) loop = (ad = require_executorUtils.asyncDone((d) => exec(ticks, condition, interalScope, context, d, void 0, internal, generatorYield))).isInstant === true ? ad.instant : (await ad.p).result;
+		while (loop) {
+			const iterScope = new require_Scope.Scope(interalScope, {});
+			ad = require_executorUtils.asyncDone((d) => exec(ticks, beforeStep, iterScope, context, d, void 0, internal, generatorYield));
+			ad.isInstant === true ? ad.instant : (await ad.p).result;
+			const res = await require_executorUtils.executeTreeAsync(ticks, context, b, [iterScope], loopTargets, internal, generatorYield);
+			if (res instanceof require_executorUtils.ExecReturn && res.returned) {
+				done(void 0, res);
+				return;
+			}
+			if (res instanceof require_executorUtils.ExecReturn && res.controlFlow) {
+				if (!loopStatementTargets.some((target) => require_executorUtils.matchesControlFlowTarget(res.controlFlow, target))) {
+					done(void 0, res);
+					return;
+				}
+				if (res.breakLoop) break;
+			}
+			ad = require_executorUtils.asyncDone((d) => exec(ticks, step, interalScope, context, d, void 0, internal, generatorYield));
+			if (isForAwait === require_types.LispType.True) internalVars["$$next"] = await internalVars["$$next"];
+			loop = (ad = require_executorUtils.asyncDone((d) => exec(ticks, condition, interalScope, context, d, void 0, internal, generatorYield))).isInstant === true ? ad.instant : (await ad.p).result;
+		}
+		done();
+	})().catch(done);
+	else {
+		require_executorUtils.syncDone((d) => exec(ticks, startStep, loopScope, context, d, void 0, internal, generatorYield));
+		internalVars["$$obj"] = require_executorUtils.syncDone((d) => exec(ticks, getIterator, loopScope, context, d, void 0, internal, generatorYield)).result;
+		require_executorUtils.syncDone((d) => exec(ticks, startInternal, interalScope, context, d, void 0, internal, generatorYield));
+		if (checkFirst) loop = require_executorUtils.syncDone((d) => exec(ticks, condition, interalScope, context, d, void 0, internal, generatorYield)).result;
+		while (loop) {
+			const iterScope = new require_Scope.Scope(interalScope, {});
+			require_executorUtils.syncDone((d) => exec(ticks, beforeStep, iterScope, context, d, void 0, internal, generatorYield));
+			const res = require_executorUtils.executeTree(ticks, context, b, [iterScope], loopTargets, internal, generatorYield);
+			if (res instanceof require_executorUtils.ExecReturn && res.returned) {
+				done(void 0, res);
+				return;
+			}
+			if (res instanceof require_executorUtils.ExecReturn && res.controlFlow) {
+				if (!loopStatementTargets.some((target) => require_executorUtils.matchesControlFlowTarget(res.controlFlow, target))) {
+					done(void 0, res);
+					return;
+				}
+				if (res.breakLoop) break;
+			}
+			require_executorUtils.syncDone((d) => exec(ticks, step, interalScope, context, d, void 0, internal, generatorYield));
+			loop = require_executorUtils.syncDone((d) => exec(ticks, condition, interalScope, context, d, void 0, internal, generatorYield)).result;
+		}
+		done();
+	}
+});
+require_opsRegistry.addOps(require_types.LispType.If, ({ exec, done, ticks, a, b, context, scope, statementLabels, internal, generatorYield }) => {
+	exec(ticks, require_Scope.sanitizeProp(a, context) ? b.t : b.f, scope, context, done, statementLabels, internal, generatorYield);
+});
+require_opsRegistry.addOps(require_types.LispType.InlineIf, ({ exec, done, ticks, a, b, context, scope, internal, generatorYield }) => {
+	exec(ticks, require_Scope.sanitizeProp(a, context) ? b.t : b.f, scope, context, done, void 0, internal, generatorYield);
+});
+require_opsRegistry.addOps(require_types.LispType.InlineIfCase, ({ done, a, b }) => done(void 0, new require_executorUtils.If(a, b)));
+require_opsRegistry.addOps(require_types.LispType.IfCase, ({ done, a, b }) => done(void 0, new require_executorUtils.If(a, b)));
+require_opsRegistry.addOps(require_types.LispType.Labeled, ({ exec, done, ticks, a, b, context, scope, statementLabels, internal, generatorYield }) => {
+	const target = require_executorUtils.createLabeledStatementTarget(require_executorUtils.normalizeStatementLabel(a));
+	exec(ticks, b, scope, context, (...args) => {
+		if (args.length === 1) {
+			done(args[0]);
+			return;
+		}
+		const res = args[1];
+		if (res instanceof require_executorUtils.ExecReturn && res.controlFlow && target) {
+			if (require_executorUtils.matchesControlFlowTarget(res.controlFlow, target)) {
+				done();
+				return;
+			}
+		}
+		done(void 0, res);
+	}, require_executorUtils.addControlFlowTarget(statementLabels, target), internal, generatorYield);
+});
+require_opsRegistry.addOps(require_types.LispType.Switch, ({ exec, done, ticks, a, b, context, scope, statementLabels, internal, generatorYield }) => {
+	const switchTarget = require_executorUtils.createSwitchTarget();
+	const switchTargets = require_executorUtils.addControlFlowTarget(statementLabels, switchTarget);
+	exec(ticks, a, scope, context, (...args) => {
+		if (args.length === 1) {
+			done(args[0]);
+			return;
+		}
+		let toTest = args[1];
+		toTest = require_Scope.sanitizeProp(toTest, context);
+		if (exec === require_executorUtils.execSync) {
+			let res;
+			let isTrue = false;
+			for (const caseItem of b) if (isTrue || (isTrue = !caseItem[1] || toTest === require_Scope.sanitizeProp(require_executorUtils.syncDone((d) => exec(ticks, caseItem[1], scope, context, d, void 0, internal, generatorYield)).result, context))) {
+				if (!caseItem[2]) continue;
+				res = require_executorUtils.executeTree(ticks, context, caseItem[2], [scope], switchTargets, internal, generatorYield);
+				if (res.controlFlow) {
+					if (!require_executorUtils.matchesControlFlowTarget(res.controlFlow, switchTarget)) {
+						done(void 0, res);
+						return;
+					}
+					if (res.breakLoop) break;
+				}
+				if (res.returned) {
+					done(void 0, res);
+					return;
+				}
+				if (!caseItem[1]) break;
+			}
+			done();
+		} else (async () => {
+			let res;
+			let isTrue = false;
+			for (const caseItem of b) {
+				let ad;
+				if (isTrue || (isTrue = !caseItem[1] || toTest === require_Scope.sanitizeProp((ad = require_executorUtils.asyncDone((d) => exec(ticks, caseItem[1], scope, context, d, void 0, internal, generatorYield))).isInstant === true ? ad.instant : (await ad.p).result, context))) {
+					if (!caseItem[2]) continue;
+					res = await require_executorUtils.executeTreeAsync(ticks, context, caseItem[2], [scope], switchTargets, internal, generatorYield);
+					if (res.controlFlow) {
+						if (!require_executorUtils.matchesControlFlowTarget(res.controlFlow, switchTarget)) {
+							done(void 0, res);
+							return;
+						}
+						if (res.breakLoop) break;
+					}
+					if (res.returned) {
+						done(void 0, res);
+						return;
+					}
+					if (!caseItem[1]) break;
+				}
+			}
+			done();
+		})().catch(done);
+	}, void 0, internal, generatorYield);
+});
+require_opsRegistry.addOps(require_types.LispType.Try, ({ exec, done, ticks, a, b, context, scope, statementLabels, internal, generatorYield }) => {
+	const [exception, catchBody, finallyBody] = b;
+	require_executorUtils.executeTreeWithDone(exec, (...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) require_executorUtils.executeTreeWithDone(exec, (...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 require_executorUtils.ExecReturn && (finallyResult.returned || finallyResult.breakLoop || finallyResult.continueLoop)) {
+					done(void 0, finallyResult);
+					return;
+				}
+				if (hadError) done(errorOrResult);
+				else if (errorOrResult instanceof require_executorUtils.ExecReturn) if (errorOrResult.returned || errorOrResult.breakLoop || errorOrResult.continueLoop) done(void 0, errorOrResult);
+				else done();
+				else done();
+			}, ticks, context, finallyBody, [new require_Scope.Scope(scope, {})], statementLabels, internal, generatorYield);
+			else if (hadError) done(errorOrResult);
+			else if (errorOrResult instanceof require_executorUtils.ExecReturn) if (errorOrResult.returned || errorOrResult.breakLoop || errorOrResult.continueLoop) done(void 0, errorOrResult);
+			else done();
+			else done();
+		};
+		if (tryHadError && tryError instanceof require_errors.SandboxError) {
+			done(tryError);
+			return;
+		}
+		if (tryHadError && catchBody && catchBody.length > 0) {
+			const sc = {};
+			if (exception) sc[exception] = tryError;
+			require_executorUtils.executeTreeWithDone(exec, (...catchArgs) => {
+				const catchHadError = catchArgs.length === 1;
+				executeFinallyAndComplete(catchHadError, catchHadError ? catchArgs[0] : catchArgs.length > 1 ? catchArgs[1] : void 0);
+			}, ticks, context, catchBody, [new require_Scope.Scope(scope, sc)], statementLabels, internal, generatorYield);
+		} else executeFinallyAndComplete(tryHadError, tryHadError ? tryError : tryResult);
+	}, ticks, context, a, [new require_Scope.Scope(scope)], statementLabels, internal, generatorYield);
+});
+require_opsRegistry.addOps(require_types.LispType.Expression, ({ done, a }) => done(void 0, a.pop()));
+//#endregion

package/dist/cjs/executor/ops/functions.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/functions.js

@@ -0,0 +1,55 @@
+const require_errors = require("../../utils/errors.js");
+const require_CodeString = require("../../utils/CodeString.js");
+const require_types = require("../../utils/types.js");
+const require_Scope = require("../../utils/Scope.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/functions.ts
+require_opsRegistry.addOps(require_types.LispType.ArrowFunction, ({ done, ticks, a, b, obj, context, scope, internal }) => {
+	if (typeof obj[2] === "string" || obj[2] instanceof require_CodeString.CodeString) if (context.allowJit && context.evalContext) obj[2] = b = context.evalContext.lispifyFunction(new require_CodeString.CodeString(obj[2]), context.constants);
+	else throw new require_errors.SandboxCapabilityError("Unevaluated code detected, JIT not allowed");
+	const argNames = a.slice(1);
+	if (a[0]) done(void 0, require_executorUtils.createFunctionAsync(argNames, b, ticks, context, scope, void 0, internal));
+	else done(void 0, require_executorUtils.createFunction(argNames, b, ticks, context, scope, void 0, internal));
+});
+require_opsRegistry.addOps(require_types.LispType.Function, ({ done, ticks, a, b, obj, context, scope, internal }) => {
+	if (typeof obj[2] === "string" || obj[2] instanceof require_CodeString.CodeString) if (context.allowJit && context.evalContext) obj[2] = b = context.evalContext.lispifyFunction(new require_CodeString.CodeString(obj[2]), context.constants, false, {
+		generatorDepth: a[1] === require_types.LispType.True ? 1 : 0,
+		asyncDepth: a[0] === require_types.LispType.True ? 1 : 0,
+		lispDepth: 0
+	});
+	else throw new require_errors.SandboxCapabilityError("Unevaluated code detected, JIT not allowed");
+	const isAsync = a[0];
+	const isGenerator = a[1];
+	const name = a[2];
+	const argNames = a.slice(3);
+	let func;
+	if (isAsync === require_types.LispType.True && isGenerator === require_types.LispType.True) func = require_executorUtils.createAsyncGeneratorFunction(argNames, b, ticks, context, scope, name, internal);
+	else if (isGenerator === require_types.LispType.True) func = require_executorUtils.createGeneratorFunction(argNames, b, ticks, context, scope, name, internal);
+	else if (isAsync === require_types.LispType.True) func = require_executorUtils.createFunctionAsync(argNames, b, ticks, context, scope, name, internal);
+	else func = require_executorUtils.createFunction(argNames, b, ticks, context, scope, name, internal);
+	if (name) scope.declare(name, require_types.VarType.var, func, false, internal);
+	done(void 0, func);
+});
+require_opsRegistry.addOps(require_types.LispType.InlineFunction, ({ done, ticks, a, b, obj, context, scope, internal }) => {
+	if (typeof obj[2] === "string" || obj[2] instanceof require_CodeString.CodeString) if (context.allowJit && context.evalContext) obj[2] = b = context.evalContext.lispifyFunction(new require_CodeString.CodeString(obj[2]), context.constants, false, {
+		generatorDepth: a[1] === require_types.LispType.True ? 1 : 0,
+		asyncDepth: a[0] === require_types.LispType.True ? 1 : 0,
+		lispDepth: 0
+	});
+	else throw new require_errors.SandboxCapabilityError("Unevaluated code detected, JIT not allowed");
+	const isAsync = a[0];
+	const isGenerator = a[1];
+	const name = a[2];
+	const argNames = a.slice(3);
+	if (name) scope = new require_Scope.Scope(scope, {});
+	let func;
+	if (isAsync === require_types.LispType.True && isGenerator === require_types.LispType.True) func = require_executorUtils.createAsyncGeneratorFunction(argNames, b, ticks, context, scope, name, internal);
+	else if (isGenerator === require_types.LispType.True) func = require_executorUtils.createGeneratorFunction(argNames, b, ticks, context, scope, name, internal);
+	else if (isAsync === require_types.LispType.True) func = require_executorUtils.createFunctionAsync(argNames, b, ticks, context, scope, name, internal);
+	else func = require_executorUtils.createFunction(argNames, b, ticks, context, scope, name, internal);
+	if (name) scope.declare(name, require_types.VarType.let, func, false, internal);
+	done(void 0, func);
+});
+//#endregion

package/dist/cjs/executor/ops/index.js

@@ -0,0 +1,11 @@
+require("./prop.js");
+require("./call.js");
+require("./object.js");
+require("./literals.js");
+require("./unary.js");
+require("./assignment.js");
+require("./comparison.js");
+require("./variables.js");
+require("./misc.js");
+require("./functions.js");
+require("./control.js");

package/dist/cjs/executor/ops/literals.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/literals.js

@@ -0,0 +1,45 @@
+const require_errors = require("../../utils/errors.js");
+const require_types = require("../../utils/types.js");
+const require_Scope = require("../../utils/Scope.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/literals.ts
+require_opsRegistry.addOps(require_types.LispType.Number, ({ done, b }) => done(void 0, Number(b.replace(/_/g, ""))));
+require_opsRegistry.addOps(require_types.LispType.BigInt, ({ done, b }) => done(void 0, BigInt(b.replace(/_/g, ""))));
+require_opsRegistry.addOps(require_types.LispType.RegexIndex, ({ done, b, context }) => {
+	const reg = context.constants.regexes[parseInt(b)];
+	if (!context.ctx.globalsWhitelist.has(RegExp)) throw new require_errors.SandboxCapabilityError("Regex not permitted");
+	else done(void 0, new ((context.evals.get(RegExp)) ?? RegExp)(reg.regex, reg.flags));
+});
+require_opsRegistry.addOps(require_types.LispType.LiteralIndex, (params) => {
+	const { exec, done, ticks, b, context, scope, internal, generatorYield } = params;
+	const [, name, js] = context.constants.literals[parseInt(b)];
+	const found = [];
+	let f;
+	const resnums = [];
+	while (f = require_executorUtils.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];
+		}
+		const result = name.replace(/(\\\\)*(\\)?\${(\d+)}/g, (match, $$, $, num) => {
+			if ($) return match;
+			const res = reses[num];
+			return ($$ ? $$ : "") + `${require_Scope.sanitizeProp(res, context)}`;
+		});
+		if (require_executorUtils.checkHaltExpectedTicks(params, BigInt(result.length))) return;
+		done(void 0, result);
+	}, void 0, internal, generatorYield);
+});
+//#endregion

package/dist/cjs/executor/ops/misc.d.ts

@@ -0,0 +1 @@
+export {};