@cuxt/sandboxjs 0.1.0 → 0.1.3

package/dist/cjs/SandboxExec.js

@@ -0,0 +1,227 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_errors = require("./utils/errors.js");
+const require_ExecContext = require("./utils/ExecContext.js");
+require("./utils/index.js");
+const require_executorUtils = require("./executor/executorUtils.js");
+require("./executor/index.js");
+//#region src/SandboxExec.ts
+function subscribeSet(obj, name, callback, context) {
+	const names = context.setSubscriptions.get(obj) || /* @__PURE__ */ new Map();
+	context.setSubscriptions.set(obj, names);
+	const callbacks = names.get(name) || /* @__PURE__ */ new Set();
+	names.set(name, callbacks);
+	callbacks.add(callback);
+	let changeCbs;
+	const val = obj[name];
+	if (val instanceof Object) {
+		changeCbs = context.changeSubscriptions.get(val) || /* @__PURE__ */ new Set();
+		changeCbs.add(callback);
+		context.changeSubscriptions.set(val, changeCbs);
+	}
+	return { unsubscribe: () => {
+		callbacks.delete(callback);
+		changeCbs?.delete(callback);
+	} };
+}
+var SandboxExec = class SandboxExec {
+	constructor(options, evalContext) {
+		this.evalContext = evalContext;
+		this.setSubscriptions = /* @__PURE__ */ new WeakMap();
+		this.changeSubscriptions = /* @__PURE__ */ new WeakMap();
+		this.sandboxFunctions = /* @__PURE__ */ new WeakMap();
+		this.haltSubscriptions = /* @__PURE__ */ new Set();
+		this.resumeSubscriptions = /* @__PURE__ */ new Set();
+		this.halted = false;
+		this.timeoutHandleCounter = 0;
+		this.setTimeoutHandles = /* @__PURE__ */ new Map();
+		this.setIntervalHandles = /* @__PURE__ */ new Map();
+		const opt = Object.assign({
+			audit: false,
+			forbidFunctionCalls: false,
+			forbidFunctionCreation: false,
+			globals: SandboxExec.SAFE_GLOBALS,
+			symbolWhitelist: SandboxExec.SAFE_SYMBOLS,
+			prototypeWhitelist: SandboxExec.SAFE_PROTOTYPES,
+			maxParserRecursionDepth: 256,
+			nonBlocking: false,
+			functionReplacements: /* @__PURE__ */ new Map()
+		}, options || {});
+		this.context = require_ExecContext.createContext(this, opt);
+	}
+	static get SAFE_GLOBALS() {
+		return {
+			globalThis,
+			Function,
+			eval,
+			console: {
+				debug: console.debug,
+				error: console.error,
+				info: console.info,
+				log: console.log,
+				table: console.table,
+				warn: console.warn
+			},
+			isFinite,
+			isNaN,
+			parseFloat,
+			parseInt,
+			decodeURI,
+			decodeURIComponent,
+			encodeURI,
+			encodeURIComponent,
+			escape,
+			unescape,
+			Boolean,
+			Number,
+			BigInt,
+			String,
+			Object,
+			Array,
+			Symbol,
+			Error,
+			EvalError,
+			RangeError,
+			ReferenceError,
+			SyntaxError,
+			TypeError,
+			URIError,
+			Int8Array,
+			Uint8Array,
+			Uint8ClampedArray,
+			Int16Array,
+			Uint16Array,
+			Int32Array,
+			Uint32Array,
+			Float32Array,
+			Float64Array,
+			Map,
+			Set,
+			WeakMap,
+			WeakSet,
+			Promise,
+			Intl,
+			JSON,
+			Math,
+			Date,
+			RegExp
+		};
+	}
+	static get SAFE_SYMBOLS() {
+		const safeSymbols = {};
+		for (const key of [
+			"asyncIterator",
+			"iterator",
+			"match",
+			"matchAll",
+			"replace",
+			"search",
+			"split"
+		]) {
+			const value = Symbol[key];
+			if (typeof value === "symbol") safeSymbols[key] = value;
+		}
+		return safeSymbols;
+	}
+	static get SAFE_PROTOTYPES() {
+		const protos = [
+			Function,
+			Boolean,
+			Number,
+			BigInt,
+			String,
+			Date,
+			Error,
+			Array,
+			Int8Array,
+			Uint8Array,
+			Uint8ClampedArray,
+			Int16Array,
+			Uint16Array,
+			Int32Array,
+			Uint32Array,
+			Float32Array,
+			Float64Array,
+			Map,
+			Set,
+			WeakMap,
+			WeakSet,
+			Promise,
+			Symbol,
+			Date,
+			RegExp,
+			Response,
+			Request,
+			Headers,
+			FormData
+		];
+		const map = /* @__PURE__ */ new Map();
+		protos.forEach((proto) => {
+			map.set(proto, /* @__PURE__ */ new Set());
+		});
+		map.set(Object, new Set([
+			"constructor",
+			"name",
+			"entries",
+			"fromEntries",
+			"getOwnPropertyNames",
+			"is",
+			"keys",
+			"hasOwnProperty",
+			"isPrototypeOf",
+			"propertyIsEnumerable",
+			"toLocaleString",
+			"toString",
+			"valueOf",
+			"values"
+		]));
+		return map;
+	}
+	subscribeGet(callback, context) {
+		context.getSubscriptions.add(callback);
+		return { unsubscribe: () => context.getSubscriptions.delete(callback) };
+	}
+	subscribeSet(obj, name, callback, context) {
+		return subscribeSet(obj, name, callback, context);
+	}
+	subscribeSetGlobal(obj, name, callback) {
+		return subscribeSet(obj, name, callback, this);
+	}
+	subscribeHalt(cb) {
+		this.haltSubscriptions.add(cb);
+		return { unsubscribe: () => {
+			this.haltSubscriptions.delete(cb);
+		} };
+	}
+	subscribeResume(cb) {
+		this.resumeSubscriptions.add(cb);
+		return { unsubscribe: () => {
+			this.resumeSubscriptions.delete(cb);
+		} };
+	}
+	haltExecution(haltContext = { type: "manual" }) {
+		if (this.halted) return;
+		this.halted = true;
+		for (const cb of this.haltSubscriptions) cb(haltContext);
+	}
+	resumeExecution() {
+		if (!this.halted) return;
+		if (this.context.ticks.tickLimit !== void 0 && this.context.ticks.ticks >= this.context.ticks.tickLimit) throw new require_errors.SandboxExecutionQuotaExceededError("Cannot resume execution: tick limit exceeded");
+		this.halted = false;
+		for (const cb of this.resumeSubscriptions) cb();
+	}
+	getContext(fn) {
+		return this.sandboxFunctions.get(fn);
+	}
+	executeTree(context, scopes = []) {
+		return require_executorUtils.executeTree(context.ctx.ticks, context, context.tree, scopes, void 0, false);
+	}
+	executeTreeAsync(context, scopes = []) {
+		return require_executorUtils.executeTreeAsync(context.ctx.ticks, context, context.tree, scopes, void 0, false);
+	}
+};
+//#endregion
+exports.SandboxExec = SandboxExec;
+exports.default = SandboxExec;

package/{build/eval.d.ts → dist/cjs/eval/index.d.ts}

@@ -1,8 +1,11 @@
-import { lispifyFunction } from './parser.js';
-import { IExecContext } from './utils.js';
+import { lispifyFunction } from '../parser';
+import { IExecContext } from '../utils';
 export interface IEvalContext {
     sandboxFunction: typeof sandboxFunction;
     sandboxAsyncFunction: typeof sandboxAsyncFunction;
+    sandboxGeneratorFunction: typeof sandboxGeneratorFunction;
+    sandboxAsyncGeneratorFunction: typeof sandboxAsyncGeneratorFunction;
+    sandboxedSymbol: typeof sandboxedSymbol;
     sandboxedEval: (func: SandboxFunction, context: IExecContext) => SandboxEval;
     sandboxedSetTimeout: typeof sandboxedSetTimeout;
     sandboxedSetInterval: typeof sandboxedSetInterval;
@@ -17,9 +20,14 @@ export type SandboxSetInterval = (handler: TimerHandler, timeout?: number, ...ar
 export type SandboxClearTimeout = (handle: number) => void;
 export type SandboxClearInterval = (handle: number) => void;
 export declare function createEvalContext(): IEvalContext;
+export declare function sandboxedSymbol(context: IExecContext): Function;
 export declare function sandboxFunction(context: IExecContext): SandboxFunction;
 export type SandboxAsyncFunction = (code: string, ...args: string[]) => () => Promise<unknown>;
 export declare function sandboxAsyncFunction(context: IExecContext): SandboxAsyncFunction;
+export type SandboxGeneratorFunction = (code: string, ...args: string[]) => () => Iterator<unknown> & Iterable<unknown>;
+export declare function sandboxGeneratorFunction(context: IExecContext): SandboxGeneratorFunction;
+export type SandboxAsyncGeneratorFunction = (code: string, ...args: string[]) => () => AsyncGenerator<unknown, unknown, unknown>;
+export declare function sandboxAsyncGeneratorFunction(context: IExecContext): SandboxAsyncGeneratorFunction;
 export declare function sandboxedEval(func: SandboxFunction, context: IExecContext): SandboxEval;
 export declare function sandboxedSetTimeout(func: SandboxFunction, context: IExecContext): SandboxSetTimeout;
 export declare function sandboxedClearTimeout(context: IExecContext): SandboxClearTimeout;

package/dist/cjs/eval/index.js

@@ -0,0 +1,233 @@
+const require_types = require("../utils/types.js");
+const require_ExecContext = require("../utils/ExecContext.js");
+require("../utils/index.js");
+const require_executorUtils = require("../executor/executorUtils.js");
+require("../executor/index.js");
+const require_parserUtils = require("../parser/parserUtils.js");
+require("../parser/index.js");
+//#region src/eval/index.ts
+function createEvalContext() {
+	return {
+		sandboxFunction,
+		sandboxAsyncFunction,
+		sandboxGeneratorFunction,
+		sandboxAsyncGeneratorFunction,
+		sandboxedSymbol,
+		sandboxedEval,
+		sandboxedSetTimeout,
+		sandboxedSetInterval,
+		sandboxedClearTimeout,
+		sandboxedClearInterval,
+		lispifyFunction: require_parserUtils.lispifyFunction
+	};
+}
+function sandboxedSymbol(context) {
+	return require_ExecContext.getSandboxSymbolCtor(context.ctx.sandboxSymbols);
+}
+function SB() {}
+function sandboxFunction(context) {
+	SandboxFunction.prototype = SB.prototype;
+	return SandboxFunction;
+	function SandboxFunction(...params) {
+		const parsed = require_parserUtils.default(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return require_executorUtils.createFunction(params, parsed.tree, context.ctx.ticks, {
+			...context,
+			constants: parsed.constants,
+			tree: parsed.tree
+		}, void 0, "anonymous");
+	}
+}
+function SAF() {}
+function sandboxAsyncFunction(context) {
+	SandboxAsyncFunction.prototype = SAF.prototype;
+	return SandboxAsyncFunction;
+	function SandboxAsyncFunction(...params) {
+		const parsed = require_parserUtils.default(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return require_executorUtils.createFunctionAsync(params, parsed.tree, context.ctx.ticks, {
+			...context,
+			constants: parsed.constants,
+			tree: parsed.tree
+		}, void 0, "anonymous");
+	}
+}
+function SGF() {}
+function sandboxGeneratorFunction(context) {
+	SandboxGeneratorFunction.prototype = SGF.prototype;
+	return SandboxGeneratorFunction;
+	function SandboxGeneratorFunction(...params) {
+		const parsed = require_parserUtils.default(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return require_executorUtils.createGeneratorFunction(params, parsed.tree, context.ctx.ticks, {
+			...context,
+			constants: parsed.constants,
+			tree: parsed.tree
+		}, void 0, "anonymous");
+	}
+}
+function SAGF() {}
+function sandboxAsyncGeneratorFunction(context) {
+	SandboxAsyncGeneratorFunction.prototype = SAGF.prototype;
+	return SandboxAsyncGeneratorFunction;
+	function SandboxAsyncGeneratorFunction(...params) {
+		const parsed = require_parserUtils.default(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return require_executorUtils.createAsyncGeneratorFunction(params, parsed.tree, context.ctx.ticks, {
+			...context,
+			constants: parsed.constants,
+			tree: parsed.tree
+		}, void 0, "anonymous");
+	}
+}
+function SE() {}
+function sandboxedEval(func, context) {
+	sandboxEval.prototype = SE.prototype;
+	return sandboxEval;
+	function sandboxEval(code) {
+		const parsed = require_parserUtils.default(code, false, false, context.ctx.options.maxParserRecursionDepth);
+		const tree = wrapLastStatementInReturn(parsed.tree);
+		return require_executorUtils.createFunction([], tree, context.ctx.ticks, {
+			...context,
+			constants: parsed.constants,
+			tree
+		}, void 0, "anonymous")();
+	}
+}
+function wrapLastStatementInReturn(tree) {
+	if (tree.length === 0) return tree;
+	const newTree = [...tree];
+	const lastIndex = newTree.length - 1;
+	const lastStmt = newTree[lastIndex];
+	if (Array.isArray(lastStmt) && lastStmt.length >= 1) {
+		const op = lastStmt[0];
+		if (op === require_types.LispType.Return || op === require_types.LispType.Throw) return newTree;
+		if ([
+			require_types.LispType.Let,
+			require_types.LispType.Const,
+			require_types.LispType.Var,
+			require_types.LispType.Function,
+			require_types.LispType.If,
+			require_types.LispType.Loop,
+			require_types.LispType.Try,
+			require_types.LispType.Switch,
+			require_types.LispType.InternalBlock,
+			require_types.LispType.Expression
+		].includes(op)) return newTree;
+		newTree[lastIndex] = [
+			require_types.LispType.Return,
+			require_types.LispType.None,
+			lastStmt
+		];
+	}
+	return newTree;
+}
+function sST() {}
+function sandboxedSetTimeout(func, context) {
+	sandboxSetTimeout.prototype = sST.prototype;
+	return sandboxSetTimeout;
+	function sandboxSetTimeout(handler, timeout, ...args) {
+		const sandbox = context.ctx.sandbox;
+		const exec = (...a) => {
+			const h = typeof handler === "string" ? func(handler) : handler;
+			haltsub.unsubscribe();
+			contsub.unsubscribe();
+			sandbox.setTimeoutHandles.delete(sandBoxhandle);
+			return h(...a);
+		};
+		const sandBoxhandle = ++sandbox.timeoutHandleCounter;
+		let start = Date.now();
+		let handle = setTimeout(exec, timeout, ...args);
+		let elapsed = 0;
+		const haltsub = sandbox.subscribeHalt(() => {
+			elapsed = Date.now() - start + elapsed;
+			clearTimeout(handle);
+		});
+		const contsub = sandbox.subscribeResume(() => {
+			start = Date.now();
+			const remaining = Math.floor((timeout || 0) - elapsed);
+			handle = setTimeout(exec, remaining, ...args);
+			sandbox.setTimeoutHandles.set(sandBoxhandle, {
+				handle,
+				haltsub,
+				contsub
+			});
+		});
+		sandbox.setTimeoutHandles.set(sandBoxhandle, {
+			handle,
+			haltsub,
+			contsub
+		});
+		return sandBoxhandle;
+	}
+}
+function sCT() {}
+function sandboxedClearTimeout(context) {
+	sandboxClearTimeout.prototype = sCT.prototype;
+	return sandboxClearTimeout;
+	function sandboxClearTimeout(handle) {
+		const sandbox = context.ctx.sandbox;
+		const timeoutHandle = sandbox.setTimeoutHandles.get(handle);
+		if (timeoutHandle) {
+			clearTimeout(timeoutHandle.handle);
+			timeoutHandle.haltsub.unsubscribe();
+			timeoutHandle.contsub.unsubscribe();
+			sandbox.setTimeoutHandles.delete(handle);
+		}
+	}
+}
+function sCI() {}
+function sandboxedClearInterval(context) {
+	sandboxClearInterval.prototype = sCI.prototype;
+	return sandboxClearInterval;
+	function sandboxClearInterval(handle) {
+		const sandbox = context.ctx.sandbox;
+		const intervalHandle = sandbox.setIntervalHandles.get(handle);
+		if (intervalHandle) {
+			clearInterval(intervalHandle.handle);
+			clearTimeout(intervalHandle.handle);
+			intervalHandle.haltsub.unsubscribe();
+			intervalHandle.contsub.unsubscribe();
+			sandbox.setIntervalHandles.delete(handle);
+		}
+	}
+}
+function sSI() {}
+function sandboxedSetInterval(func, context) {
+	sandboxSetInterval.prototype = sSI.prototype;
+	return sandboxSetInterval;
+	function sandboxSetInterval(handler, timeout, ...args) {
+		const sandbox = context.ctx.sandbox;
+		const h = typeof handler === "string" ? func(handler) : handler;
+		const exec = (...a) => {
+			start = Date.now();
+			elapsed = 0;
+			return h(...a);
+		};
+		const sandBoxhandle = ++sandbox.timeoutHandleCounter;
+		let start = Date.now();
+		let handle = setInterval(exec, timeout, ...args);
+		let elapsed = 0;
+		const haltsub = sandbox.subscribeHalt(() => {
+			elapsed = Date.now() - start + elapsed;
+			clearInterval(handle);
+			clearTimeout(handle);
+		});
+		const contsub = sandbox.subscribeResume(() => {
+			start = Date.now();
+			handle = setTimeout(() => {
+				start = Date.now();
+				elapsed = 0;
+				handle = setInterval(exec, timeout, ...args);
+				handlObj.handle = handle;
+				exec(...args);
+			}, Math.floor((timeout || 0) - elapsed), ...args);
+			handlObj.handle = handle;
+		});
+		const handlObj = {
+			handle,
+			haltsub,
+			contsub
+		};
+		sandbox.setIntervalHandles.set(sandBoxhandle, handlObj);
+		return sandBoxhandle;
+	}
+}
+//#endregion
+exports.createEvalContext = createEvalContext;

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

@@ -0,0 +1,161 @@
+import { LispItem, Lisp, StatementLabel } from '../parser';
+import { LispType, Prop, Scope, Unknown, IAuditReport, IExecContext, IScope, optional, Ticks } from '../utils';
+import { Execution } from './opsRegistry';
+export type Done<T = any> = (err?: any, res?: T | typeof optional) => void;
+export type ControlFlowAction = 'break' | 'continue';
+export interface ControlFlowSignal {
+    type: ControlFlowAction;
+    label?: string;
+}
+interface ControlFlowTarget {
+    label?: string;
+    acceptsBreak: boolean;
+    acceptsContinue: boolean;
+    acceptsUnlabeledBreak: boolean;
+    acceptsUnlabeledContinue: boolean;
+}
+export type ControlFlowTargets = readonly ControlFlowTarget[] | undefined;
+export declare class ExecReturn<T> {
+    auditReport: IAuditReport | undefined;
+    result: T;
+    returned: boolean;
+    controlFlow?: ControlFlowSignal | undefined;
+    constructor(auditReport: IAuditReport | undefined, result: T, returned: boolean, controlFlow?: ControlFlowSignal | undefined);
+    get breakLoop(): boolean;
+    get continueLoop(): boolean;
+}
+export interface IChange {
+    type: string;
+}
+export interface ICreate extends IChange {
+    type: 'create';
+    prop: number | string;
+}
+export interface IReplace extends IChange {
+    type: 'replace';
+}
+export interface IDelete extends IChange {
+    type: 'delete';
+    prop: number | string;
+}
+export interface IReverse extends IChange {
+    type: 'reverse';
+}
+export interface ISort extends IChange {
+    type: 'sort';
+}
+export interface IPush extends IChange {
+    type: 'push';
+    added: unknown[];
+}
+export interface IPop extends IChange {
+    type: 'pop';
+    removed: unknown[];
+}
+export interface IShift extends IChange {
+    type: 'shift';
+    removed: unknown[];
+}
+export interface IUnShift extends IChange {
+    type: 'unshift';
+    added: unknown[];
+}
+export interface ISplice extends IChange {
+    type: 'splice';
+    startIndex: number;
+    deleteCount: number;
+    added: unknown[];
+    removed: unknown[];
+}
+export interface ICopyWithin extends IChange {
+    type: 'copyWithin';
+    startIndex: number;
+    endIndex: number;
+    added: unknown[];
+    removed: unknown[];
+}
+export type Change = ICreate | IReplace | IDelete | IReverse | ISort | IPush | IPop | IUnShift | IShift | ISplice | ICopyWithin;
+export declare function normalizeStatementLabel(label: StatementLabel | undefined): string | undefined;
+export declare function normalizeStatementLabels(label: LispItem | StatementLabel | undefined): string[];
+export declare function createLoopTarget(label?: string, acceptsUnlabeled?: boolean): ControlFlowTarget;
+export declare function createSwitchTarget(label?: string): ControlFlowTarget;
+export declare function createLabeledStatementTarget(label?: string): ControlFlowTarget | undefined;
+export declare function addControlFlowTarget(controlFlowTargets: ControlFlowTargets, target?: ControlFlowTarget): ControlFlowTargets;
+export declare function addControlFlowTargets(controlFlowTargets: ControlFlowTargets, targets: ControlFlowTarget[]): ControlFlowTargets;
+export declare function matchesControlFlowTarget(signal: ControlFlowSignal, target: ControlFlowTarget): boolean;
+export declare function findControlFlowTarget(controlFlowTargets: ControlFlowTargets, type: ControlFlowAction, label?: string): ControlFlowTarget | null | undefined;
+export declare function createFunction(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string, internal?: boolean): (...args: unknown[]) => unknown;
+export declare function createFunctionAsync(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string, internal?: boolean): (...args: unknown[]) => Promise<unknown>;
+export declare class YieldValue {
+    value: unknown;
+    delegate: boolean;
+    constructor(value: unknown, delegate: boolean);
+}
+export declare function createGeneratorFunction(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string, internal?: boolean): (this: Unknown, ...args: unknown[]) => Iterator<unknown, any, any> & Iterable<unknown>;
+export declare function createAsyncGeneratorFunction(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string, internal?: boolean): (this: Unknown, ...args: unknown[]) => AsyncGenerator;
+export declare function assignCheck(obj: Prop, context: IExecContext, op?: string): void;
+export declare const arrayChange: Set<(() => undefined) | ((...items: never[]) => number) | ((compareFn?: ((a: never, b: never) => number) | undefined) => never[]) | ((target: number, start: number, end?: number) => never[])>;
+export declare class KeyVal {
+    key: PropertyKey | SpreadObject;
+    val: unknown;
+    constructor(key: PropertyKey | SpreadObject, val: unknown);
+}
+export declare class SpreadObject {
+    item: {
+        [key: string]: unknown;
+    };
+    constructor(item: {
+        [key: string]: unknown;
+    });
+}
+export declare class SpreadArray {
+    item: unknown[];
+    constructor(item: unknown[]);
+}
+export declare class ArrayHole {
+}
+export declare class If {
+    t: Lisp;
+    f: Lisp;
+    label?: string | undefined;
+    constructor(t: Lisp, f: Lisp, label?: string | undefined);
+}
+export declare const literalRegex: RegExp;
+export { ops, addOps } from './opsRegistry';
+export declare const prorptyKeyTypes: string[];
+export declare function isPropertyKey(val: unknown): val is PropertyKey;
+export declare function hasPossibleProperties(val: unknown): val is {};
+export declare function execMany(ticks: Ticks, exec: Execution, tree: Lisp[], done: Done, scope: Scope, context: IExecContext, statementLabels: ControlFlowTargets, internal: boolean, generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined): void;
+export interface AsyncDoneRet {
+    isInstant: boolean;
+    instant: any;
+    p: Promise<{
+        result: any;
+    }>;
+}
+export declare function asyncDone(callback: (done: Done) => void): AsyncDoneRet;
+export declare function syncDone(callback: (done: Done) => void): {
+    result: any;
+};
+export declare function execAsync<T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, doneOriginal: Done<T>, statementLabels: ControlFlowTargets, internal: boolean, generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined): Promise<void>;
+export declare function execSync<T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done<T>, statementLabels: ControlFlowTargets, internal: boolean, generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined): void;
+type OpsCallbackParams<a, b, obj, bobj> = {
+    op: LispType;
+    exec: Execution;
+    a: a;
+    b: b;
+    obj: obj;
+    bobj: bobj;
+    ticks: Ticks;
+    tree: LispItem;
+    scope: Scope;
+    context: IExecContext;
+    done: Done;
+    statementLabels: ControlFlowTargets;
+    internal: boolean;
+    generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined;
+};
+export declare function checkHaltExpectedTicks(params: OpsCallbackParams<any, any, any, any>, expectTicks?: bigint): boolean;
+export declare function executeTree<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes: IScope[] | undefined, statementLabels: ControlFlowTargets, internal: boolean, generatorYield?: ((yv: YieldValue, done?: Done) => void) | undefined): ExecReturn<T>;
+export declare function executeTreeAsync<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes: IScope[] | undefined, statementLabels: ControlFlowTargets, internal: boolean, generatorYield?: ((yv: YieldValue, done?: Done) => void) | undefined): Promise<ExecReturn<T>>;
+export declare function executeTreeWithDone(exec: Execution, done: Done, ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes: IScope[] | undefined, statementLabels: ControlFlowTargets, internal: boolean, generatorYield?: ((yv: YieldValue, done?: Done) => void) | undefined): void;