@cuxt/sandboxjs 0.1.0 → 0.1.3

package/dist/cjs/utils/types.js

@@ -0,0 +1,164 @@
+//#region src/utils/types.ts
+var AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
+var GeneratorFunction = Object.getPrototypeOf(function* () {}).constructor;
+var AsyncGeneratorFunction = Object.getPrototypeOf(async function* () {}).constructor;
+var NON_BLOCKING_THRESHOLD = 50000n;
+var reservedWords = new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"let",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with"
+]);
+var VarType = /* @__PURE__ */ function(VarType) {
+	VarType["let"] = "let";
+	VarType["const"] = "const";
+	VarType["var"] = "var";
+	VarType["internal"] = "internal";
+	return VarType;
+}({});
+var LispType = /* @__PURE__ */ function(LispType) {
+	LispType[LispType["None"] = 0] = "None";
+	LispType[LispType["Prop"] = 1] = "Prop";
+	LispType[LispType["StringIndex"] = 2] = "StringIndex";
+	LispType[LispType["Let"] = 3] = "Let";
+	LispType[LispType["Const"] = 4] = "Const";
+	LispType[LispType["Call"] = 5] = "Call";
+	LispType[LispType["KeyVal"] = 6] = "KeyVal";
+	LispType[LispType["Number"] = 7] = "Number";
+	LispType[LispType["Return"] = 8] = "Return";
+	LispType[LispType["Assign"] = 9] = "Assign";
+	LispType[LispType["InlineFunction"] = 10] = "InlineFunction";
+	LispType[LispType["ArrowFunction"] = 11] = "ArrowFunction";
+	LispType[LispType["CreateArray"] = 12] = "CreateArray";
+	LispType[LispType["If"] = 13] = "If";
+	LispType[LispType["IfCase"] = 14] = "IfCase";
+	LispType[LispType["InlineIf"] = 15] = "InlineIf";
+	LispType[LispType["InlineIfCase"] = 16] = "InlineIfCase";
+	LispType[LispType["SpreadObject"] = 17] = "SpreadObject";
+	LispType[LispType["SpreadArray"] = 18] = "SpreadArray";
+	LispType[LispType["ArrayProp"] = 19] = "ArrayProp";
+	LispType[LispType["PropOptional"] = 20] = "PropOptional";
+	LispType[LispType["CallOptional"] = 21] = "CallOptional";
+	LispType[LispType["CreateObject"] = 22] = "CreateObject";
+	LispType[LispType["Group"] = 23] = "Group";
+	LispType[LispType["Not"] = 24] = "Not";
+	LispType[LispType["IncrementBefore"] = 25] = "IncrementBefore";
+	LispType[LispType["IncrementAfter"] = 26] = "IncrementAfter";
+	LispType[LispType["DecrementBefore"] = 27] = "DecrementBefore";
+	LispType[LispType["DecrementAfter"] = 28] = "DecrementAfter";
+	LispType[LispType["And"] = 29] = "And";
+	LispType[LispType["Or"] = 30] = "Or";
+	LispType[LispType["StrictNotEqual"] = 31] = "StrictNotEqual";
+	LispType[LispType["StrictEqual"] = 32] = "StrictEqual";
+	LispType[LispType["Plus"] = 33] = "Plus";
+	LispType[LispType["Var"] = 34] = "Var";
+	LispType[LispType["GlobalSymbol"] = 35] = "GlobalSymbol";
+	LispType[LispType["Literal"] = 36] = "Literal";
+	LispType[LispType["Function"] = 37] = "Function";
+	LispType[LispType["Loop"] = 38] = "Loop";
+	LispType[LispType["Try"] = 39] = "Try";
+	LispType[LispType["Switch"] = 40] = "Switch";
+	LispType[LispType["SwitchCase"] = 41] = "SwitchCase";
+	LispType[LispType["InternalBlock"] = 42] = "InternalBlock";
+	LispType[LispType["Expression"] = 43] = "Expression";
+	LispType[LispType["Await"] = 44] = "Await";
+	LispType[LispType["New"] = 45] = "New";
+	LispType[LispType["Throw"] = 46] = "Throw";
+	LispType[LispType["Minus"] = 47] = "Minus";
+	LispType[LispType["Divide"] = 48] = "Divide";
+	LispType[LispType["Power"] = 49] = "Power";
+	LispType[LispType["Multiply"] = 50] = "Multiply";
+	LispType[LispType["Modulus"] = 51] = "Modulus";
+	LispType[LispType["Equal"] = 52] = "Equal";
+	LispType[LispType["NotEqual"] = 53] = "NotEqual";
+	LispType[LispType["SmallerEqualThan"] = 54] = "SmallerEqualThan";
+	LispType[LispType["LargerEqualThan"] = 55] = "LargerEqualThan";
+	LispType[LispType["SmallerThan"] = 56] = "SmallerThan";
+	LispType[LispType["LargerThan"] = 57] = "LargerThan";
+	LispType[LispType["Negative"] = 58] = "Negative";
+	LispType[LispType["Positive"] = 59] = "Positive";
+	LispType[LispType["Typeof"] = 60] = "Typeof";
+	LispType[LispType["Delete"] = 61] = "Delete";
+	LispType[LispType["Instanceof"] = 62] = "Instanceof";
+	LispType[LispType["In"] = 63] = "In";
+	LispType[LispType["Inverse"] = 64] = "Inverse";
+	LispType[LispType["SubractEquals"] = 65] = "SubractEquals";
+	LispType[LispType["AddEquals"] = 66] = "AddEquals";
+	LispType[LispType["DivideEquals"] = 67] = "DivideEquals";
+	LispType[LispType["PowerEquals"] = 68] = "PowerEquals";
+	LispType[LispType["MultiplyEquals"] = 69] = "MultiplyEquals";
+	LispType[LispType["ModulusEquals"] = 70] = "ModulusEquals";
+	LispType[LispType["BitNegateEquals"] = 71] = "BitNegateEquals";
+	LispType[LispType["BitAndEquals"] = 72] = "BitAndEquals";
+	LispType[LispType["BitOrEquals"] = 73] = "BitOrEquals";
+	LispType[LispType["UnsignedShiftRightEquals"] = 74] = "UnsignedShiftRightEquals";
+	LispType[LispType["ShiftRightEquals"] = 75] = "ShiftRightEquals";
+	LispType[LispType["ShiftLeftEquals"] = 76] = "ShiftLeftEquals";
+	LispType[LispType["BitAnd"] = 77] = "BitAnd";
+	LispType[LispType["BitOr"] = 78] = "BitOr";
+	LispType[LispType["BitNegate"] = 79] = "BitNegate";
+	LispType[LispType["BitShiftLeft"] = 80] = "BitShiftLeft";
+	LispType[LispType["BitShiftRight"] = 81] = "BitShiftRight";
+	LispType[LispType["BitUnsignedShiftRight"] = 82] = "BitUnsignedShiftRight";
+	LispType[LispType["BigInt"] = 83] = "BigInt";
+	LispType[LispType["LiteralIndex"] = 84] = "LiteralIndex";
+	LispType[LispType["RegexIndex"] = 85] = "RegexIndex";
+	LispType[LispType["LoopAction"] = 86] = "LoopAction";
+	LispType[LispType["Void"] = 87] = "Void";
+	LispType[LispType["True"] = 88] = "True";
+	LispType[LispType["NullishCoalescing"] = 89] = "NullishCoalescing";
+	LispType[LispType["AndEquals"] = 90] = "AndEquals";
+	LispType[LispType["OrEquals"] = 91] = "OrEquals";
+	LispType[LispType["NullishCoalescingEquals"] = 92] = "NullishCoalescingEquals";
+	LispType[LispType["Block"] = 93] = "Block";
+	LispType[LispType["Labeled"] = 94] = "Labeled";
+	LispType[LispType["Internal"] = 95] = "Internal";
+	LispType[LispType["Yield"] = 96] = "Yield";
+	LispType[LispType["YieldDelegate"] = 97] = "YieldDelegate";
+	LispType[LispType["Hole"] = 98] = "Hole";
+	LispType[LispType["LispEnumSize"] = 99] = "LispEnumSize";
+	return LispType;
+}({});
+//#endregion
+exports.AsyncFunction = AsyncFunction;
+exports.AsyncGeneratorFunction = AsyncGeneratorFunction;
+exports.GeneratorFunction = GeneratorFunction;
+exports.LispType = LispType;
+exports.NON_BLOCKING_THRESHOLD = NON_BLOCKING_THRESHOLD;
+exports.VarType = VarType;
+exports.reservedWords = reservedWords;

package/dist/cjs/utils/unraw.js

@@ -0,0 +1,145 @@
+//#region src/utils/unraw.ts
+/**
+* Parse a string as a base-16 number. This is more strict than `parseInt` as it
+* will not allow any other characters, including (for example) "+", "-", and
+* ".".
+* @param hex A string containing a hexadecimal number.
+* @returns The parsed integer, or `NaN` if the string is not a valid hex
+* number.
+*/
+function parseHexToInt(hex) {
+	return !hex.match(/[^a-f0-9]/i) ? parseInt(hex, 16) : NaN;
+}
+/**
+* Check the validity and length of a hexadecimal code and optionally enforces
+* a specific number of hex digits.
+* @param hex The string to validate and parse.
+* @param errorName The name of the error message to throw a `SyntaxError` with
+* if `hex` is invalid. This is used to index `errorMessages`.
+* @param enforcedLength If provided, will throw an error if `hex` is not
+* exactly this many characters.
+* @returns The parsed hex number as a normal number.
+* @throws {SyntaxError} If the code is not valid.
+*/
+function validateAndParseHex(hex, errorName, enforcedLength) {
+	const parsedHex = parseHexToInt(hex);
+	if (Number.isNaN(parsedHex) || enforcedLength !== void 0 && enforcedLength !== hex.length) throw new SyntaxError(errorName + ": " + hex);
+	return parsedHex;
+}
+/**
+* Parse a two-digit hexadecimal character escape code.
+* @param code The two-digit hexadecimal number that represents the character to
+* output.
+* @returns The single character represented by the code.
+* @throws {SyntaxError} If the code is not valid hex or is not the right
+* length.
+*/
+function parseHexadecimalCode(code) {
+	const parsedCode = validateAndParseHex(code, "Malformed Hexadecimal", 2);
+	return String.fromCharCode(parsedCode);
+}
+/**
+* Parse a four-digit Unicode character escape code.
+* @param code The four-digit unicode number that represents the character to
+* output.
+* @param surrogateCode Optional four-digit unicode surrogate that represents
+* the other half of the character to output.
+* @returns The single character represented by the code.
+* @throws {SyntaxError} If the codes are not valid hex or are not the right
+* length.
+*/
+function parseUnicodeCode(code, surrogateCode) {
+	const parsedCode = validateAndParseHex(code, "Malformed Unicode", 4);
+	if (surrogateCode !== void 0) {
+		const parsedSurrogateCode = validateAndParseHex(surrogateCode, "Malformed Unicode", 4);
+		return String.fromCharCode(parsedCode, parsedSurrogateCode);
+	}
+	return String.fromCharCode(parsedCode);
+}
+/**
+* Test if the text is surrounded by curly braces (`{}`).
+* @param text Text to check.
+* @returns `true` if the text is in the form `{*}`.
+*/
+function isCurlyBraced(text) {
+	return text.charAt(0) === "{" && text.charAt(text.length - 1) === "}";
+}
+/**
+* Parse a Unicode code point character escape code.
+* @param codePoint A unicode escape code point, including the surrounding curly
+* braces.
+* @returns The single character represented by the code.
+* @throws {SyntaxError} If the code is not valid hex or does not have the
+* surrounding curly braces.
+*/
+function parseUnicodeCodePointCode(codePoint) {
+	if (!isCurlyBraced(codePoint)) throw new SyntaxError("Malformed Unicode: +" + codePoint);
+	const parsedCode = validateAndParseHex(codePoint.slice(1, -1), "Malformed Unicode");
+	try {
+		return String.fromCodePoint(parsedCode);
+	} catch (err) {
+		throw err instanceof RangeError ? /* @__PURE__ */ new SyntaxError("Code Point Limit:" + parsedCode) : err;
+	}
+}
+/**
+* Map of unescaped letters to their corresponding special JS escape characters.
+* Intentionally does not include characters that map to themselves like "\'".
+*/
+var singleCharacterEscapes = new Map([
+	["b", "\b"],
+	["f", "\f"],
+	["n", "\n"],
+	["r", "\r"],
+	["t", "	"],
+	["v", "\v"],
+	["0", "\0"]
+]);
+/**
+* Parse a single character escape sequence and return the matching character.
+* If none is matched, defaults to `code`.
+* @param code A single character code.
+*/
+function parseSingleCharacterCode(code) {
+	return singleCharacterEscapes.get(code) || code;
+}
+/**
+* Matches every escape sequence possible, including invalid ones.
+*
+* All capture groups (described below) are unique (only one will match), except
+* for 4, which can only potentially match if 3 does.
+*
+* **Capture Groups:**
+* 0. A single backslash
+* 1. Hexadecimal code
+* 2. Unicode code point code with surrounding curly braces
+* 3. Unicode escape code with surrogate
+* 4. Surrogate code
+* 5. Unicode escape code without surrogate
+* 6. Octal code _NOTE: includes "0"._
+* 7. A single character (will never be \, x, u, or 0-3)
+*/
+var escapeMatch = /\\(?:(\\)|x([\s\S]{0,2})|u(\{[^}]*\}?)|u([\s\S]{4})\\u([^{][\s\S]{0,3})|u([\s\S]{0,4})|([0-3]?[0-7]{1,2})|([\s\S])|$)/g;
+/**
+* Replace raw escape character strings with their escape characters.
+* @param raw A string where escape characters are represented as raw string
+* values like `\'` rather than `'`.
+* @param allowOctals If `true`, will process the now-deprecated octal escape
+* sequences (ie, `\111`).
+* @returns The processed string, with escape characters replaced by their
+* respective actual Unicode characters.
+*/
+function unraw(raw) {
+	return raw.replace(escapeMatch, function(_, backslash, hex, codePoint, unicodeWithSurrogate, surrogate, unicode, octal, singleCharacter) {
+		if (backslash !== void 0) return "\\";
+		if (hex !== void 0) return parseHexadecimalCode(hex);
+		if (codePoint !== void 0) return parseUnicodeCodePointCode(codePoint);
+		if (unicodeWithSurrogate !== void 0) return parseUnicodeCode(unicodeWithSurrogate, surrogate);
+		if (unicode !== void 0) return parseUnicodeCode(unicode);
+		if (octal === "0") return "\0";
+		if (octal !== void 0) throw new SyntaxError("Octal Deprecation: " + octal);
+		if (singleCharacter !== void 0) return parseSingleCharacterCode(singleCharacter);
+		throw new SyntaxError("End of string");
+	});
+}
+//#endregion
+exports.default = unraw;

package/dist/{node → esm}/Sandbox.d.ts

@@ -1,11 +1,19 @@
-import { IExecContext, IOptionParams, IScope } from './utils.js';
-import { ExecReturn } from './executor.js';
-import SandboxExec from './SandboxExec.js';
-export { LocalScope, SandboxExecutionTreeError, SandboxCapabilityError, SandboxAccessError, SandboxError, } from './utils.js';
-export default class Sandbox extends SandboxExec {
+import { IExecContext, IOptionParams, IScope } from './utils';
+import { ExecReturn } from './executor';
+import { default as SandboxExec } from './SandboxExec';
+export { ParseError } from './parser';
+export { LocalScope, SandboxExecutionTreeError, SandboxCapabilityError, SandboxAccessError, SandboxExecutionQuotaExceededError, SandboxError, delaySynchronousResult, } from './utils';
+export type * from './utils';
+export type * from './parser';
+export type * from './executor';
+export type * from './eval';
+export declare class Sandbox extends SandboxExec {
     constructor(options?: IOptionParams);
     static audit<T>(code: string, scopes?: IScope[]): ExecReturn<T>;
-    static parse(code: string): import("./parser.js").IExecutionTree;
+    static parse(code: string): import('./parser').IExecutionTree;
+    get Function(): Function;
+    get AsyncFunction(): Function;
+    get eval(): Function;
     compile<T>(code: string, optimize?: boolean): (...scopes: IScope[]) => {
         context: IExecContext;
         run: () => T;
@@ -23,3 +31,4 @@ export default class Sandbox extends SandboxExec {
         run: () => Promise<T>;
     };
 }
+export default Sandbox;

package/dist/esm/Sandbox.js

@@ -0,0 +1,115 @@
+import { SandboxAccessError, SandboxCapabilityError, SandboxError, SandboxExecutionQuotaExceededError, SandboxExecutionTreeError } from "./utils/errors.js";
+import { AsyncFunction } from "./utils/types.js";
+import { LocalScope, delaySynchronousResult, sanitizeScopes } from "./utils/Scope.js";
+import { createExecContext } from "./utils/ExecContext.js";
+import "./utils/index.js";
+import parse, { ParseError } from "./parser/parserUtils.js";
+import "./parser/index.js";
+import { createEvalContext } from "./eval/index.js";
+import { SandboxExec } from "./SandboxExec.js";
+//#region src/Sandbox.ts
+var Sandbox = class extends SandboxExec {
+	constructor(options) {
+		super(options, createEvalContext());
+	}
+	static audit(code, scopes = []) {
+		const globals = {};
+		for (const i of Object.getOwnPropertyNames(globalThis)) globals[i] = globalThis[i];
+		const sandbox = new SandboxExec({
+			globals,
+			audit: true
+		});
+		return sandbox.executeTree(createExecContext(sandbox, parse(code, true, false, sandbox.context.options.maxParserRecursionDepth), createEvalContext()), scopes);
+	}
+	static parse(code) {
+		return parse(code, true);
+	}
+	get Function() {
+		return createExecContext(this, {
+			tree: [],
+			constants: {
+				strings: [],
+				eager: true,
+				literals: [],
+				maxDepth: this.context.options.maxParserRecursionDepth,
+				regexes: []
+			}
+		}, this.evalContext).evals.get(Function);
+	}
+	get AsyncFunction() {
+		return createExecContext(this, {
+			tree: [],
+			constants: {
+				strings: [],
+				eager: true,
+				literals: [],
+				maxDepth: this.context.options.maxParserRecursionDepth,
+				regexes: []
+			}
+		}, this.evalContext).evals.get(AsyncFunction);
+	}
+	get eval() {
+		return createExecContext(this, {
+			tree: [],
+			constants: {
+				strings: [],
+				eager: true,
+				literals: [],
+				maxDepth: this.context.options.maxParserRecursionDepth,
+				regexes: []
+			}
+		}, this.evalContext).evals.get(eval);
+	}
+	compile(code, optimize = false) {
+		if (this.context.options.nonBlocking) throw new SandboxCapabilityError("Non-blocking mode is enabled, use Sandbox.compileAsync() instead.");
+		const parsed = parse(code, optimize, false, this.context.options.maxParserRecursionDepth);
+		const context = createExecContext(this, parsed, this.evalContext);
+		const exec = (...scopes) => {
+			sanitizeScopes(scopes, context);
+			return {
+				context,
+				run: () => this.executeTree(context, [...scopes]).result
+			};
+		};
+		return exec;
+	}
+	compileAsync(code, optimize = false) {
+		const parsed = parse(code, optimize, false, this.context.options.maxParserRecursionDepth);
+		const context = createExecContext(this, parsed, this.evalContext);
+		const exec = (...scopes) => {
+			sanitizeScopes(scopes, context);
+			return {
+				context,
+				run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result)
+			};
+		};
+		return exec;
+	}
+	compileExpression(code, optimize = false) {
+		const parsed = parse(code, optimize, true, this.context.options.maxParserRecursionDepth);
+		const context = createExecContext(this, parsed, this.evalContext);
+		const exec = (...scopes) => {
+			sanitizeScopes(scopes, context);
+			return {
+				context,
+				run: () => this.executeTree(context, [...scopes]).result
+			};
+		};
+		return exec;
+	}
+	compileExpressionAsync(code, optimize = false) {
+		const parsed = parse(code, optimize, true, this.context.options.maxParserRecursionDepth);
+		const context = createExecContext(this, parsed, this.evalContext);
+		const exec = (...scopes) => {
+			return {
+				context,
+				run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result)
+			};
+		};
+		return exec;
+	}
+};
+//#endregion
+export { LocalScope, ParseError, Sandbox, Sandbox as default, SandboxAccessError, SandboxCapabilityError, SandboxError, SandboxExecutionQuotaExceededError, SandboxExecutionTreeError, delaySynchronousResult };
+
+//# sourceMappingURL=Sandbox.js.map

package/dist/esm/Sandbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sandbox.js","names":[],"sources":["../../src/Sandbox.ts"],"sourcesContent":["import { AsyncFunction, createExecContext, SandboxCapabilityError, sanitizeScopes } from './utils';\nimport type { IExecContext, IOptionParams, IScope } from './utils';\nimport { createEvalContext } from './eval';\nimport { ExecReturn } from './executor';\nimport parse from './parser';\nimport SandboxExec from './SandboxExec';\nexport { ParseError } from './parser';\nexport {\n  LocalScope,\n  SandboxExecutionTreeError,\n  SandboxCapabilityError,\n  SandboxAccessError,\n  SandboxExecutionQuotaExceededError,\n  SandboxError,\n  delaySynchronousResult,\n} from './utils';\n\nexport type * from './utils';\nexport type * from './parser';\nexport type * from './executor';\nexport type * from './eval';\n\nexport class Sandbox extends SandboxExec {\n  constructor(options?: IOptionParams) {\n    super(options, createEvalContext());\n  }\n\n  static audit<T>(code: string, scopes: IScope[] = []): ExecReturn<T> {\n    const globals: Record<string, unknown> = {};\n    for (const i of Object.getOwnPropertyNames(globalThis) as [keyof typeof globalThis]) {\n      globals[i] = globalThis[i];\n    }\n    const sandbox = new SandboxExec({\n      globals,\n      audit: true,\n    });\n    return sandbox.executeTree(\n      createExecContext(\n        sandbox,\n        parse(code, true, false, sandbox.context.options.maxParserRecursionDepth),\n        createEvalContext(),\n      ),\n      scopes,\n    );\n  }\n\n  static parse(code: string) {\n    return parse(code, true);\n  }\n\n  get Function() {\n    const context = createExecContext(\n      this,\n      {\n        tree: [],\n        constants: {\n          strings: [],\n          eager: true,\n          literals: [],\n          maxDepth: this.context.options.maxParserRecursionDepth,\n          regexes: [],\n        },\n      },\n      this.evalContext,\n    );\n    return context.evals.get(Function)!;\n  }\n\n  get AsyncFunction() {\n    const context = createExecContext(\n      this,\n      {\n        tree: [],\n        constants: {\n          strings: [],\n          eager: true,\n          literals: [],\n          maxDepth: this.context.options.maxParserRecursionDepth,\n          regexes: [],\n        },\n      },\n      this.evalContext,\n    );\n    return context.evals.get(AsyncFunction)!;\n  }\n\n  get eval() {\n    const context = createExecContext(\n      this,\n      {\n        tree: [],\n        constants: {\n          strings: [],\n          eager: true,\n          literals: [],\n          maxDepth: this.context.options.maxParserRecursionDepth,\n          regexes: [],\n        },\n      },\n      this.evalContext,\n    );\n    return context.evals.get(eval)!;\n  }\n\n  compile<T>(\n    code: string,\n    optimize = false,\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => T } {\n    if (this.context.options.nonBlocking)\n      throw new SandboxCapabilityError(\n        'Non-blocking mode is enabled, use Sandbox.compileAsync() instead.',\n      );\n    const parsed = parse(code, optimize, false, this.context.options.maxParserRecursionDepth);\n    const context = createExecContext(this, parsed, this.evalContext);\n    const exec = (...scopes: IScope[]) => {\n      sanitizeScopes(scopes, context);\n      return { context, run: () => this.executeTree<T>(context, [...scopes]).result };\n    };\n    return exec;\n  }\n\n  compileAsync<T>(\n    code: string,\n    optimize = false,\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => Promise<T> } {\n    const parsed = parse(code, optimize, false, this.context.options.maxParserRecursionDepth);\n    const context = createExecContext(this, parsed, this.evalContext);\n    const exec = (...scopes: IScope[]) => {\n      sanitizeScopes(scopes, context);\n      return {\n        context,\n        run: () => this.executeTreeAsync<T>(context, [...scopes]).then((ret) => ret.result),\n      };\n    };\n    return exec;\n  }\n\n  compileExpression<T>(\n    code: string,\n    optimize = false,\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => T } {\n    const parsed = parse(code, optimize, true, this.context.options.maxParserRecursionDepth);\n    const context = createExecContext(this, parsed, this.evalContext);\n    const exec = (...scopes: IScope[]) => {\n      sanitizeScopes(scopes, context);\n      return { context, run: () => this.executeTree<T>(context, [...scopes]).result };\n    };\n    return exec;\n  }\n\n  compileExpressionAsync<T>(\n    code: string,\n    optimize = false,\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => Promise<T> } {\n    const parsed = parse(code, optimize, true, this.context.options.maxParserRecursionDepth);\n    const context = createExecContext(this, parsed, this.evalContext);\n    const exec = (...scopes: IScope[]) => {\n      return {\n        context,\n        run: () => this.executeTreeAsync<T>(context, [...scopes]).then((ret) => ret.result),\n      };\n    };\n    return exec;\n  }\n}\n\nexport default Sandbox;\n"],"mappings":"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"}

package/{build → dist/esm}/SandboxExec.d.ts

@@ -1,8 +1,7 @@
-import { IEvalContext } from './eval.js';
-import { Change, ExecReturn } from './executor.js';
-import { IContext, IExecContext, IGlobals, IOptionParams, IScope, Scope, SubscriptionSubject, Ticks } from './utils.js';
-export { IOptions, IContext, IExecContext, LocalScope, SandboxExecutionTreeError, SandboxCapabilityError, SandboxAccessError, SandboxError, } from './utils.js';
-export default class SandboxExec {
+import { IEvalContext } from './eval';
+import { Change, ExecReturn } from './executor';
+import { IContext, IExecContext, IGlobals, IOptionParams, IScope, ISymbolWhitelist, SubscriptionSubject, HaltContext } from './utils';
+export declare class SandboxExec {
     evalContext?: IEvalContext | undefined;
     readonly context: IContext;
     readonly setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
@@ -32,6 +31,7 @@ export default class SandboxExec {
     }>;
     constructor(options?: IOptionParams, evalContext?: IEvalContext | undefined);
     static get SAFE_GLOBALS(): IGlobals;
+    static get SAFE_SYMBOLS(): ISymbolWhitelist;
     static get SAFE_PROTOTYPES(): Map<any, Set<string>>;
     subscribeGet(callback: (obj: SubscriptionSubject, name: string) => void, context: IExecContext): {
         unsubscribe: () => void;
@@ -42,25 +42,16 @@ export default class SandboxExec {
     subscribeSetGlobal(obj: SubscriptionSubject, name: string, callback: (modification: Change) => void): {
         unsubscribe: () => void;
     };
-    subscribeHalt(cb: (args?: {
-        error: Error;
-        ticks: Ticks;
-        scope: Scope;
-        context: IExecContext;
-    }) => void): {
+    subscribeHalt(cb: (context: HaltContext) => void): {
         unsubscribe: () => void;
     };
     subscribeResume(cb: () => void): {
         unsubscribe: () => void;
     };
-    haltExecution(haltContext?: {
-        error: Error;
-        ticks: Ticks;
-        scope: Scope;
-        context: IExecContext;
-    }): void;
+    haltExecution(haltContext?: HaltContext): void;
     resumeExecution(): void;
     getContext(fn: (...args: any[]) => any): IExecContext | undefined;
     executeTree<T>(context: IExecContext, scopes?: IScope[]): ExecReturn<T>;
     executeTreeAsync<T>(context: IExecContext, scopes?: IScope[]): Promise<ExecReturn<T>>;
 }
+export default SandboxExec;