@cuxt/sandboxjs 0.1.1 → 0.1.3

package/dist/esm/SandboxExec.js

@@ -0,0 +1,224 @@
+import { SandboxExecutionQuotaExceededError } from "./utils/errors.js";
+import { createContext } from "./utils/ExecContext.js";
+import "./utils/index.js";
+import { executeTree, executeTreeAsync } from "./executor/executorUtils.js";
+import "./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 = 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 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 executeTree(context.ctx.ticks, context, context.tree, scopes, void 0, false);
+	}
+	executeTreeAsync(context, scopes = []) {
+		return executeTreeAsync(context.ctx.ticks, context, context.tree, scopes, void 0, false);
+	}
+};
+//#endregion
+export { SandboxExec, SandboxExec as default };
+
+//# sourceMappingURL=SandboxExec.js.map

package/dist/esm/SandboxExec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxExec.js","names":[],"sources":["../../src/SandboxExec.ts"],"sourcesContent":["import type { IEvalContext } from './eval';\nimport { Change, ExecReturn, executeTree, executeTreeAsync } from './executor';\nimport { createContext, SandboxExecutionQuotaExceededError } from './utils';\nimport type {\n  IContext,\n  IExecContext,\n  IGlobals,\n  IOptionParams,\n  IOptions,\n  IScope,\n  ISymbolWhitelist,\n  SubscriptionSubject,\n  HaltContext,\n} from './utils';\n\nfunction subscribeSet(\n  obj: object,\n  name: string,\n  callback: (modification: Change) => void,\n  context: {\n    setSubscriptions: WeakMap<\n      SubscriptionSubject,\n      Map<string, Set<(modification: Change) => void>>\n    >;\n    changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;\n  },\n): { unsubscribe: () => void } {\n  const names =\n    context.setSubscriptions.get(obj) || new Map<string, Set<(modification: Change) => void>>();\n  context.setSubscriptions.set(obj, names);\n  const callbacks = names.get(name) || new Set();\n  names.set(name, callbacks);\n  callbacks.add(callback);\n  let changeCbs: Set<(modification: Change) => void>;\n  const val = (obj as any)[name] as unknown;\n  if (val instanceof Object) {\n    changeCbs = context.changeSubscriptions.get(val) || new Set();\n    changeCbs.add(callback);\n    context.changeSubscriptions.set(val, changeCbs);\n  }\n  return {\n    unsubscribe: () => {\n      callbacks.delete(callback);\n      changeCbs?.delete(callback);\n    },\n  };\n}\n\nexport class SandboxExec {\n  public readonly context: IContext;\n  public readonly setSubscriptions: WeakMap<\n    SubscriptionSubject,\n    Map<string, Set<(modification: Change) => void>>\n  > = new WeakMap();\n  public readonly changeSubscriptions: WeakMap<\n    SubscriptionSubject,\n    Set<(modification: Change) => void>\n  > = new WeakMap();\n  public readonly sandboxFunctions: WeakMap<Function, IExecContext> = new WeakMap();\n  private haltSubscriptions: Set<(context: HaltContext) => void> = new Set();\n  private resumeSubscriptions: Set<() => void> = new Set();\n  public halted = false;\n  timeoutHandleCounter = 0;\n  public readonly setTimeoutHandles = new Map<\n    number,\n    {\n      handle: number;\n      haltsub: { unsubscribe: () => void };\n      contsub: { unsubscribe: () => void };\n    }\n  >();\n  public readonly setIntervalHandles = new Map<\n    number,\n    {\n      handle: number;\n      haltsub: { unsubscribe: () => void };\n      contsub: { unsubscribe: () => void };\n    }\n  >();\n  constructor(\n    options?: IOptionParams,\n    public evalContext?: IEvalContext,\n  ) {\n    const opt: IOptions = Object.assign(\n      {\n        audit: false,\n        forbidFunctionCalls: false,\n        forbidFunctionCreation: false,\n        globals: SandboxExec.SAFE_GLOBALS,\n        symbolWhitelist: SandboxExec.SAFE_SYMBOLS,\n        prototypeWhitelist: SandboxExec.SAFE_PROTOTYPES,\n        maxParserRecursionDepth: 256,\n        nonBlocking: false,\n        functionReplacements: new Map<\n          Function,\n          (ctx: IExecContext, builtInReplacement?: Function) => Function\n        >(),\n      },\n      options || {},\n    );\n    this.context = createContext(this, opt);\n  }\n\n  static get SAFE_GLOBALS(): IGlobals {\n    return {\n      globalThis,\n      Function,\n      eval,\n      console: {\n        debug: console.debug,\n        error: console.error,\n        info: console.info,\n        log: console.log,\n        table: console.table,\n        warn: console.warn,\n      },\n      isFinite,\n      isNaN,\n      parseFloat,\n      parseInt,\n      decodeURI,\n      decodeURIComponent,\n      encodeURI,\n      encodeURIComponent,\n      escape,\n      unescape,\n      Boolean,\n      Number,\n      BigInt,\n      String,\n      Object,\n      Array,\n      Symbol,\n      Error,\n      EvalError,\n      RangeError,\n      ReferenceError,\n      SyntaxError,\n      TypeError,\n      URIError,\n      Int8Array,\n      Uint8Array,\n      Uint8ClampedArray,\n      Int16Array,\n      Uint16Array,\n      Int32Array,\n      Uint32Array,\n      Float32Array,\n      Float64Array,\n      Map,\n      Set,\n      WeakMap,\n      WeakSet,\n      Promise,\n      Intl,\n      JSON,\n      Math,\n      Date,\n      RegExp,\n    };\n  }\n\n  static get SAFE_SYMBOLS(): ISymbolWhitelist {\n    const safeSymbols: ISymbolWhitelist = {};\n    for (const key of [\n      'asyncIterator',\n      'iterator',\n      'match',\n      'matchAll',\n      'replace',\n      'search',\n      'split',\n    ]) {\n      const value = (Symbol as unknown as Record<string, symbol | undefined>)[key];\n      if (typeof value === 'symbol') {\n        safeSymbols[key] = value;\n      }\n    }\n    return safeSymbols;\n  }\n\n  static get SAFE_PROTOTYPES(): Map<any, Set<string>> {\n    const protos = [\n      Function,\n      Boolean,\n      Number,\n      BigInt,\n      String,\n      Date,\n      Error,\n      Array,\n      Int8Array,\n      Uint8Array,\n      Uint8ClampedArray,\n      Int16Array,\n      Uint16Array,\n      Int32Array,\n      Uint32Array,\n      Float32Array,\n      Float64Array,\n      Map,\n      Set,\n      WeakMap,\n      WeakSet,\n      Promise,\n      Symbol,\n      Date,\n      RegExp,\n      // Fetch API\n      Response,\n      Request,\n      Headers,\n      FormData,\n    ];\n    const map = new Map<any, Set<string>>();\n    protos.forEach((proto) => {\n      map.set(proto, new Set());\n    });\n    map.set(\n      Object,\n      new Set([\n        'constructor',\n        'name',\n        'entries',\n        'fromEntries',\n        'getOwnPropertyNames',\n        'is',\n        'keys',\n        'hasOwnProperty',\n        'isPrototypeOf',\n        'propertyIsEnumerable',\n        'toLocaleString',\n        'toString',\n        'valueOf',\n        'values',\n      ]),\n    );\n    return map;\n  }\n\n  subscribeGet(\n    callback: (obj: SubscriptionSubject, name: string) => void,\n    context: IExecContext,\n  ): { unsubscribe: () => void } {\n    context.getSubscriptions.add(callback);\n    return { unsubscribe: () => context.getSubscriptions.delete(callback) };\n  }\n\n  subscribeSet(\n    obj: object,\n    name: string,\n    callback: (modification: Change) => void,\n    context: SandboxExec | IExecContext,\n  ): { unsubscribe: () => void } {\n    return subscribeSet(obj, name, callback, context);\n  }\n\n  subscribeSetGlobal(\n    obj: SubscriptionSubject,\n    name: string,\n    callback: (modification: Change) => void,\n  ): { unsubscribe: () => void } {\n    return subscribeSet(obj, name, callback, this);\n  }\n\n  subscribeHalt(cb: (context: HaltContext) => void) {\n    this.haltSubscriptions.add(cb);\n    return {\n      unsubscribe: () => {\n        this.haltSubscriptions.delete(cb);\n      },\n    };\n  }\n  subscribeResume(cb: () => void) {\n    this.resumeSubscriptions.add(cb);\n    return {\n      unsubscribe: () => {\n        this.resumeSubscriptions.delete(cb);\n      },\n    };\n  }\n\n  haltExecution(haltContext: HaltContext = { type: 'manual' }) {\n    if (this.halted) return;\n    this.halted = true;\n    for (const cb of this.haltSubscriptions) {\n      cb(haltContext);\n    }\n  }\n\n  resumeExecution() {\n    if (!this.halted) return;\n    if (\n      this.context.ticks.tickLimit !== undefined &&\n      this.context.ticks.ticks >= this.context.ticks.tickLimit\n    ) {\n      throw new SandboxExecutionQuotaExceededError('Cannot resume execution: tick limit exceeded');\n    }\n    this.halted = false;\n    for (const cb of this.resumeSubscriptions) {\n      cb();\n    }\n  }\n\n  getContext(fn: (...args: any[]) => any) {\n    return this.sandboxFunctions.get(fn);\n  }\n\n  executeTree<T>(context: IExecContext, scopes: IScope[] = []): ExecReturn<T> {\n    return executeTree(context.ctx.ticks, context, context.tree, scopes, undefined, false);\n  }\n\n  executeTreeAsync<T>(context: IExecContext, scopes: IScope[] = []): Promise<ExecReturn<T>> {\n    return executeTreeAsync(context.ctx.ticks, context, context.tree, scopes, undefined, false);\n  }\n}\n\nexport default SandboxExec;\n"],"mappings":"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"}

package/dist/{eval.d.ts → esm/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/esm/eval/index.js

@@ -0,0 +1,235 @@
+import { LispType } from "../utils/types.js";
+import { getSandboxSymbolCtor } from "../utils/ExecContext.js";
+import "../utils/index.js";
+import { createAsyncGeneratorFunction, createFunction, createFunctionAsync, createGeneratorFunction } from "../executor/executorUtils.js";
+import "../executor/index.js";
+import parse, { lispifyFunction } from "../parser/parserUtils.js";
+import "../parser/index.js";
+//#region src/eval/index.ts
+function createEvalContext() {
+	return {
+		sandboxFunction,
+		sandboxAsyncFunction,
+		sandboxGeneratorFunction,
+		sandboxAsyncGeneratorFunction,
+		sandboxedSymbol,
+		sandboxedEval,
+		sandboxedSetTimeout,
+		sandboxedSetInterval,
+		sandboxedClearTimeout,
+		sandboxedClearInterval,
+		lispifyFunction
+	};
+}
+function sandboxedSymbol(context) {
+	return getSandboxSymbolCtor(context.ctx.sandboxSymbols);
+}
+function SB() {}
+function sandboxFunction(context) {
+	SandboxFunction.prototype = SB.prototype;
+	return SandboxFunction;
+	function SandboxFunction(...params) {
+		const parsed = parse(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return 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 = parse(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return 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 = parse(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return 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 = parse(params.pop() || "", false, false, context.ctx.options.maxParserRecursionDepth);
+		return 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 = parse(code, false, false, context.ctx.options.maxParserRecursionDepth);
+		const tree = wrapLastStatementInReturn(parsed.tree);
+		return 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 === LispType.Return || op === LispType.Throw) return newTree;
+		if ([
+			LispType.Let,
+			LispType.Const,
+			LispType.Var,
+			LispType.Function,
+			LispType.If,
+			LispType.Loop,
+			LispType.Try,
+			LispType.Switch,
+			LispType.InternalBlock,
+			LispType.Expression
+		].includes(op)) return newTree;
+		newTree[lastIndex] = [
+			LispType.Return,
+			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
+export { createEvalContext };
+
+//# sourceMappingURL=index.js.map

package/dist/esm/eval/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/eval/index.ts"],"sourcesContent":["import {\n  createAsyncGeneratorFunction,\n  createFunction,\n  createFunctionAsync,\n  createGeneratorFunction,\n} from '../executor';\nimport parse, { lispifyFunction } from '../parser';\nimport type { Lisp } from '../parser';\nimport { getSandboxSymbolCtor, LispType } from '../utils';\nimport type { IExecContext } from '../utils';\n\nexport interface IEvalContext {\n  sandboxFunction: typeof sandboxFunction;\n  sandboxAsyncFunction: typeof sandboxAsyncFunction;\n  sandboxGeneratorFunction: typeof sandboxGeneratorFunction;\n  sandboxAsyncGeneratorFunction: typeof sandboxAsyncGeneratorFunction;\n  sandboxedSymbol: typeof sandboxedSymbol;\n  sandboxedEval: (func: SandboxFunction, context: IExecContext) => SandboxEval;\n  sandboxedSetTimeout: typeof sandboxedSetTimeout;\n  sandboxedSetInterval: typeof sandboxedSetInterval;\n  sandboxedClearTimeout: typeof sandboxedClearTimeout;\n  sandboxedClearInterval: typeof sandboxedClearInterval;\n  lispifyFunction: typeof lispifyFunction;\n}\nexport type SandboxFunction = (code: string, ...args: string[]) => () => unknown;\nexport type SandboxEval = (code: string) => unknown;\nexport type SandboxSetTimeout = (\n  handler: TimerHandler,\n  timeout?: number,\n  ...args: unknown[]\n) => any;\nexport type SandboxSetInterval = (\n  handler: TimerHandler,\n  timeout?: number,\n  ...args: unknown[]\n) => any;\nexport type SandboxClearTimeout = (handle: number) => void;\nexport type SandboxClearInterval = (handle: number) => void;\n\nexport function createEvalContext(): IEvalContext {\n  return {\n    sandboxFunction,\n    sandboxAsyncFunction,\n    sandboxGeneratorFunction,\n    sandboxAsyncGeneratorFunction,\n    sandboxedSymbol,\n    sandboxedEval,\n    sandboxedSetTimeout,\n    sandboxedSetInterval,\n    sandboxedClearTimeout,\n    sandboxedClearInterval,\n    lispifyFunction,\n  };\n}\n\nexport function sandboxedSymbol(context: IExecContext) {\n  return getSandboxSymbolCtor(context.ctx.sandboxSymbols);\n}\n\nfunction SB() {}\nexport function sandboxFunction(context: IExecContext): SandboxFunction {\n  SandboxFunction.prototype = SB.prototype;\n  return SandboxFunction;\n  function SandboxFunction(...params: string[]) {\n    const code = params.pop() || '';\n    const parsed = parse(code, false, false, context.ctx.options.maxParserRecursionDepth);\n    return createFunction(\n      params,\n      parsed.tree,\n      context.ctx.ticks,\n      {\n        ...context,\n        constants: parsed.constants,\n        tree: parsed.tree,\n      },\n      undefined,\n      'anonymous',\n    );\n  }\n}\n\nexport type SandboxAsyncFunction = (code: string, ...args: string[]) => () => Promise<unknown>;\nfunction SAF() {}\nexport function sandboxAsyncFunction(context: IExecContext): SandboxAsyncFunction {\n  SandboxAsyncFunction.prototype = SAF.prototype;\n  return SandboxAsyncFunction;\n  function SandboxAsyncFunction(...params: string[]) {\n    const code = params.pop() || '';\n    const parsed = parse(code, false, false, context.ctx.options.maxParserRecursionDepth);\n    return createFunctionAsync(\n      params,\n      parsed.tree,\n      context.ctx.ticks,\n      {\n        ...context,\n        constants: parsed.constants,\n        tree: parsed.tree,\n      },\n      undefined,\n      'anonymous',\n    );\n  }\n}\n\nexport type SandboxGeneratorFunction = (\n  code: string,\n  ...args: string[]\n) => () => Iterator<unknown> & Iterable<unknown>;\nfunction SGF() {}\nexport function sandboxGeneratorFunction(context: IExecContext): SandboxGeneratorFunction {\n  SandboxGeneratorFunction.prototype = SGF.prototype;\n  return SandboxGeneratorFunction;\n  function SandboxGeneratorFunction(...params: string[]) {\n    const code = params.pop() || '';\n    const parsed = parse(code, false, false, context.ctx.options.maxParserRecursionDepth);\n    return createGeneratorFunction(\n      params,\n      parsed.tree,\n      context.ctx.ticks,\n      {\n        ...context,\n        constants: parsed.constants,\n        tree: parsed.tree,\n      },\n      undefined,\n      'anonymous',\n    );\n  }\n}\n\nexport type SandboxAsyncGeneratorFunction = (\n  code: string,\n  ...args: string[]\n) => () => AsyncGenerator<unknown, unknown, unknown>;\nfunction SAGF() {}\nexport function sandboxAsyncGeneratorFunction(\n  context: IExecContext,\n): SandboxAsyncGeneratorFunction {\n  SandboxAsyncGeneratorFunction.prototype = SAGF.prototype;\n  return SandboxAsyncGeneratorFunction;\n  function SandboxAsyncGeneratorFunction(...params: string[]) {\n    const code = params.pop() || '';\n    const parsed = parse(code, false, false, context.ctx.options.maxParserRecursionDepth);\n    return createAsyncGeneratorFunction(\n      params,\n      parsed.tree,\n      context.ctx.ticks,\n      {\n        ...context,\n        constants: parsed.constants,\n        tree: parsed.tree,\n      },\n      undefined,\n      'anonymous',\n    );\n  }\n}\n\nfunction SE() {}\nexport function sandboxedEval(func: SandboxFunction, context: IExecContext): SandboxEval {\n  sandboxEval.prototype = SE.prototype;\n  return sandboxEval;\n  function sandboxEval(code: string) {\n    // Parse the code and wrap last statement in return for completion value\n    const parsed = parse(code, false, false, context.ctx.options.maxParserRecursionDepth);\n    const tree = wrapLastStatementInReturn(parsed.tree);\n    // Create and execute function with modified tree\n    return createFunction(\n      [],\n      tree,\n      context.ctx.ticks,\n      {\n        ...context,\n        constants: parsed.constants,\n        tree,\n      },\n      undefined,\n      'anonymous',\n    )();\n  }\n}\n\nfunction wrapLastStatementInReturn(tree: Lisp[]): Lisp[] {\n  if (tree.length === 0) return tree;\n  const newTree = [...tree];\n  const lastIndex = newTree.length - 1;\n  const lastStmt = newTree[lastIndex];\n\n  // Only wrap if it's not already a return or throw\n  if (Array.isArray(lastStmt) && lastStmt.length >= 1) {\n    const op = lastStmt[0];\n\n    // Don't wrap Return (8) or Throw (47) - they already control flow\n    if (op === LispType.Return || op === LispType.Throw) {\n      return newTree;\n    }\n\n    // List of statement types that should have undefined completion value\n    // These match JavaScript semantics where declarations and control structures\n    // don't produce a completion value\n    const statementTypes = [\n      LispType.Let, // 3\n      LispType.Const, // 4\n      LispType.Var, // 35\n      LispType.Function, // 38\n      LispType.If, // 14\n      LispType.Loop, // 39\n      LispType.Try, // 40\n      LispType.Switch, // 41\n      LispType.InternalBlock, // 43\n      LispType.Expression, // 44\n    ];\n\n    // If the last statement is a declaration or control structure,\n    // don't wrap it (it will naturally return undefined)\n    if (statementTypes.includes(op)) {\n      return newTree;\n    }\n\n    // For all other types (expressions, operators, etc.),\n    // wrap in return to capture the completion value\n    newTree[lastIndex] = [LispType.Return, LispType.None, lastStmt];\n  }\n\n  return newTree;\n}\n\nfunction sST() {}\nexport function sandboxedSetTimeout(\n  func: SandboxFunction,\n  context: IExecContext,\n): SandboxSetTimeout {\n  sandboxSetTimeout.prototype = sST.prototype;\n  return sandboxSetTimeout;\n  function sandboxSetTimeout(handler: TimerHandler, timeout?: number, ...args: unknown[]) {\n    const sandbox = context.ctx.sandbox;\n    const exec = (...a: any[]) => {\n      const h = typeof handler === 'string' ? func(handler) : handler;\n      haltsub.unsubscribe();\n      contsub.unsubscribe();\n      sandbox.setTimeoutHandles.delete(sandBoxhandle);\n      return h(...a);\n    };\n\n    const sandBoxhandle = ++sandbox.timeoutHandleCounter;\n\n    let start = Date.now();\n    let handle: number = setTimeout(exec, timeout, ...args);\n\n    let elapsed = 0;\n    const haltsub = sandbox.subscribeHalt(() => {\n      elapsed = Date.now() - start + elapsed;\n      clearTimeout(handle);\n    });\n    const contsub = sandbox.subscribeResume(() => {\n      start = Date.now();\n      const remaining = Math.floor((timeout || 0) - elapsed);\n      handle = setTimeout(exec, remaining, ...args);\n      sandbox.setTimeoutHandles.set(sandBoxhandle, {\n        handle,\n        haltsub,\n        contsub,\n      });\n    });\n    sandbox.setTimeoutHandles.set(sandBoxhandle, {\n      handle,\n      haltsub,\n      contsub,\n    });\n    return sandBoxhandle;\n  }\n}\n\nfunction sCT() {}\nexport function sandboxedClearTimeout(context: IExecContext): SandboxClearTimeout {\n  sandboxClearTimeout.prototype = sCT.prototype;\n  return sandboxClearTimeout;\n  function sandboxClearTimeout(handle: number) {\n    const sandbox = context.ctx.sandbox;\n    const timeoutHandle = sandbox.setTimeoutHandles.get(handle);\n    if (timeoutHandle) {\n      clearTimeout(timeoutHandle.handle);\n      timeoutHandle.haltsub.unsubscribe();\n      timeoutHandle.contsub.unsubscribe();\n      sandbox.setTimeoutHandles.delete(handle);\n    }\n  }\n}\nfunction sCI() {}\nexport function sandboxedClearInterval(context: IExecContext): SandboxClearInterval {\n  sandboxClearInterval.prototype = sCI.prototype;\n  return sandboxClearInterval;\n  function sandboxClearInterval(handle: number) {\n    const sandbox = context.ctx.sandbox;\n    const intervalHandle = sandbox.setIntervalHandles.get(handle);\n    if (intervalHandle) {\n      clearInterval(intervalHandle.handle);\n      clearTimeout(intervalHandle.handle);\n      intervalHandle.haltsub.unsubscribe();\n      intervalHandle.contsub.unsubscribe();\n      sandbox.setIntervalHandles.delete(handle);\n    }\n  }\n}\n\nfunction sSI() {}\nexport function sandboxedSetInterval(\n  func: SandboxFunction,\n  context: IExecContext,\n): SandboxSetInterval {\n  sandboxSetInterval.prototype = sSI.prototype;\n  return sandboxSetInterval;\n  function sandboxSetInterval(\n    handler: TimerHandler,\n    timeout: number | undefined,\n    ...args: unknown[]\n  ) {\n    const sandbox = context.ctx.sandbox;\n    const h = typeof handler === 'string' ? func(handler) : handler;\n    const exec = (...a: any[]) => {\n      start = Date.now();\n      elapsed = 0;\n      return h(...a);\n    };\n\n    const sandBoxhandle = ++sandbox.timeoutHandleCounter;\n\n    let start = Date.now();\n    let handle: number = setInterval(exec, timeout, ...args);\n\n    let elapsed = 0;\n    const haltsub = sandbox.subscribeHalt(() => {\n      elapsed = Date.now() - start + elapsed;\n      clearInterval(handle);\n      clearTimeout(handle);\n    });\n    const contsub = sandbox.subscribeResume(() => {\n      start = Date.now();\n      handle = setTimeout(\n        () => {\n          start = Date.now();\n          elapsed = 0;\n          handle = setInterval(exec, timeout, ...args);\n          handlObj.handle = handle;\n          exec(...args);\n        },\n        Math.floor((timeout || 0) - elapsed),\n        ...args,\n      );\n      handlObj.handle = handle;\n    });\n\n    const handlObj = {\n      handle,\n      haltsub,\n      contsub,\n    };\n    sandbox.setIntervalHandles.set(sandBoxhandle, handlObj);\n    return sandBoxhandle;\n  }\n}\n"],"mappings":";;;;;;;;AAuCA,SAAgB,oBAAkC;AAChD,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;;AAGH,SAAgB,gBAAgB,SAAuB;AACrD,QAAO,qBAAqB,QAAQ,IAAI,eAAe;;AAGzD,SAAS,KAAK;AACd,SAAgB,gBAAgB,SAAwC;AACtE,iBAAgB,YAAY,GAAG;AAC/B,QAAO;CACP,SAAS,gBAAgB,GAAG,QAAkB;EAE5C,MAAM,SAAS,MADF,OAAO,KAAK,IAAI,IACF,OAAO,OAAO,QAAQ,IAAI,QAAQ,wBAAwB;AACrF,SAAO,eACL,QACA,OAAO,MACP,QAAQ,IAAI,OACZ;GACE,GAAG;GACH,WAAW,OAAO;GAClB,MAAM,OAAO;GACd,EACD,KAAA,GACA,YACD;;;AAKL,SAAS,MAAM;AACf,SAAgB,qBAAqB,SAA6C;AAChF,sBAAqB,YAAY,IAAI;AACrC,QAAO;CACP,SAAS,qBAAqB,GAAG,QAAkB;EAEjD,MAAM,SAAS,MADF,OAAO,KAAK,IAAI,IACF,OAAO,OAAO,QAAQ,IAAI,QAAQ,wBAAwB;AACrF,SAAO,oBACL,QACA,OAAO,MACP,QAAQ,IAAI,OACZ;GACE,GAAG;GACH,WAAW,OAAO;GAClB,MAAM,OAAO;GACd,EACD,KAAA,GACA,YACD;;;AAQL,SAAS,MAAM;AACf,SAAgB,yBAAyB,SAAiD;AACxF,0BAAyB,YAAY,IAAI;AACzC,QAAO;CACP,SAAS,yBAAyB,GAAG,QAAkB;EAErD,MAAM,SAAS,MADF,OAAO,KAAK,IAAI,IACF,OAAO,OAAO,QAAQ,IAAI,QAAQ,wBAAwB;AACrF,SAAO,wBACL,QACA,OAAO,MACP,QAAQ,IAAI,OACZ;GACE,GAAG;GACH,WAAW,OAAO;GAClB,MAAM,OAAO;GACd,EACD,KAAA,GACA,YACD;;;AAQL,SAAS,OAAO;AAChB,SAAgB,8BACd,SAC+B;AAC/B,+BAA8B,YAAY,KAAK;AAC/C,QAAO;CACP,SAAS,8BAA8B,GAAG,QAAkB;EAE1D,MAAM,SAAS,MADF,OAAO,KAAK,IAAI,IACF,OAAO,OAAO,QAAQ,IAAI,QAAQ,wBAAwB;AACrF,SAAO,6BACL,QACA,OAAO,MACP,QAAQ,IAAI,OACZ;GACE,GAAG;GACH,WAAW,OAAO;GAClB,MAAM,OAAO;GACd,EACD,KAAA,GACA,YACD;;;AAIL,SAAS,KAAK;AACd,SAAgB,cAAc,MAAuB,SAAoC;AACvF,aAAY,YAAY,GAAG;AAC3B,QAAO;CACP,SAAS,YAAY,MAAc;EAEjC,MAAM,SAAS,MAAM,MAAM,OAAO,OAAO,QAAQ,IAAI,QAAQ,wBAAwB;EACrF,MAAM,OAAO,0BAA0B,OAAO,KAAK;AAEnD,SAAO,eACL,EAAE,EACF,MACA,QAAQ,IAAI,OACZ;GACE,GAAG;GACH,WAAW,OAAO;GAClB;GACD,EACD,KAAA,GACA,YACD,EAAE;;;AAIP,SAAS,0BAA0B,MAAsB;AACvD,KAAI,KAAK,WAAW,EAAG,QAAO;CAC9B,MAAM,UAAU,CAAC,GAAG,KAAK;CACzB,MAAM,YAAY,QAAQ,SAAS;CACnC,MAAM,WAAW,QAAQ;AAGzB,KAAI,MAAM,QAAQ,SAAS,IAAI,SAAS,UAAU,GAAG;EACnD,MAAM,KAAK,SAAS;AAGpB,MAAI,OAAO,SAAS,UAAU,OAAO,SAAS,MAC5C,QAAO;AAqBT,MAfuB;GACrB,SAAS;GACT,SAAS;GACT,SAAS;GACT,SAAS;GACT,SAAS;GACT,SAAS;GACT,SAAS;GACT,SAAS;GACT,SAAS;GACT,SAAS;GACV,CAIkB,SAAS,GAAG,CAC7B,QAAO;AAKT,UAAQ,aAAa;GAAC,SAAS;GAAQ,SAAS;GAAM;GAAS;;AAGjE,QAAO;;AAGT,SAAS,MAAM;AACf,SAAgB,oBACd,MACA,SACmB;AACnB,mBAAkB,YAAY,IAAI;AAClC,QAAO;CACP,SAAS,kBAAkB,SAAuB,SAAkB,GAAG,MAAiB;EACtF,MAAM,UAAU,QAAQ,IAAI;EAC5B,MAAM,QAAQ,GAAG,MAAa;GAC5B,MAAM,IAAI,OAAO,YAAY,WAAW,KAAK,QAAQ,GAAG;AACxD,WAAQ,aAAa;AACrB,WAAQ,aAAa;AACrB,WAAQ,kBAAkB,OAAO,cAAc;AAC/C,UAAO,EAAE,GAAG,EAAE;;EAGhB,MAAM,gBAAgB,EAAE,QAAQ;EAEhC,IAAI,QAAQ,KAAK,KAAK;EACtB,IAAI,SAAiB,WAAW,MAAM,SAAS,GAAG,KAAK;EAEvD,IAAI,UAAU;EACd,MAAM,UAAU,QAAQ,oBAAoB;AAC1C,aAAU,KAAK,KAAK,GAAG,QAAQ;AAC/B,gBAAa,OAAO;IACpB;EACF,MAAM,UAAU,QAAQ,sBAAsB;AAC5C,WAAQ,KAAK,KAAK;GAClB,MAAM,YAAY,KAAK,OAAO,WAAW,KAAK,QAAQ;AACtD,YAAS,WAAW,MAAM,WAAW,GAAG,KAAK;AAC7C,WAAQ,kBAAkB,IAAI,eAAe;IAC3C;IACA;IACA;IACD,CAAC;IACF;AACF,UAAQ,kBAAkB,IAAI,eAAe;GAC3C;GACA;GACA;GACD,CAAC;AACF,SAAO;;;AAIX,SAAS,MAAM;AACf,SAAgB,sBAAsB,SAA4C;AAChF,qBAAoB,YAAY,IAAI;AACpC,QAAO;CACP,SAAS,oBAAoB,QAAgB;EAC3C,MAAM,UAAU,QAAQ,IAAI;EAC5B,MAAM,gBAAgB,QAAQ,kBAAkB,IAAI,OAAO;AAC3D,MAAI,eAAe;AACjB,gBAAa,cAAc,OAAO;AAClC,iBAAc,QAAQ,aAAa;AACnC,iBAAc,QAAQ,aAAa;AACnC,WAAQ,kBAAkB,OAAO,OAAO;;;;AAI9C,SAAS,MAAM;AACf,SAAgB,uBAAuB,SAA6C;AAClF,sBAAqB,YAAY,IAAI;AACrC,QAAO;CACP,SAAS,qBAAqB,QAAgB;EAC5C,MAAM,UAAU,QAAQ,IAAI;EAC5B,MAAM,iBAAiB,QAAQ,mBAAmB,IAAI,OAAO;AAC7D,MAAI,gBAAgB;AAClB,iBAAc,eAAe,OAAO;AACpC,gBAAa,eAAe,OAAO;AACnC,kBAAe,QAAQ,aAAa;AACpC,kBAAe,QAAQ,aAAa;AACpC,WAAQ,mBAAmB,OAAO,OAAO;;;;AAK/C,SAAS,MAAM;AACf,SAAgB,qBACd,MACA,SACoB;AACpB,oBAAmB,YAAY,IAAI;AACnC,QAAO;CACP,SAAS,mBACP,SACA,SACA,GAAG,MACH;EACA,MAAM,UAAU,QAAQ,IAAI;EAC5B,MAAM,IAAI,OAAO,YAAY,WAAW,KAAK,QAAQ,GAAG;EACxD,MAAM,QAAQ,GAAG,MAAa;AAC5B,WAAQ,KAAK,KAAK;AAClB,aAAU;AACV,UAAO,EAAE,GAAG,EAAE;;EAGhB,MAAM,gBAAgB,EAAE,QAAQ;EAEhC,IAAI,QAAQ,KAAK,KAAK;EACtB,IAAI,SAAiB,YAAY,MAAM,SAAS,GAAG,KAAK;EAExD,IAAI,UAAU;EACd,MAAM,UAAU,QAAQ,oBAAoB;AAC1C,aAAU,KAAK,KAAK,GAAG,QAAQ;AAC/B,iBAAc,OAAO;AACrB,gBAAa,OAAO;IACpB;EACF,MAAM,UAAU,QAAQ,sBAAsB;AAC5C,WAAQ,KAAK,KAAK;AAClB,YAAS,iBACD;AACJ,YAAQ,KAAK,KAAK;AAClB,cAAU;AACV,aAAS,YAAY,MAAM,SAAS,GAAG,KAAK;AAC5C,aAAS,SAAS;AAClB,SAAK,GAAG,KAAK;MAEf,KAAK,OAAO,WAAW,KAAK,QAAQ,EACpC,GAAG,KACJ;AACD,YAAS,SAAS;IAClB;EAEF,MAAM,WAAW;GACf;GACA;GACA;GACD;AACD,UAAQ,mBAAmB,IAAI,eAAe,SAAS;AACvD,SAAO"}