@cuxt/sandboxjs 0.1.1 → 0.1.4

package/dist/cjs/utils/CodeString.d.ts

@@ -0,0 +1,16 @@
+export declare class CodeString {
+    start: number;
+    end: number;
+    ref: {
+        str: string;
+    };
+    constructor(str: string | CodeString);
+    substring(start: number, end?: number): CodeString;
+    get length(): number;
+    char(i: number): string | undefined;
+    toString(): string;
+    trimStart(): CodeString;
+    slice(start: number, end?: number): CodeString;
+    trim(): CodeString;
+    valueOf(): string;
+}

package/dist/cjs/utils/CodeString.js

@@ -0,0 +1,64 @@
+//#region src/utils/CodeString.ts
+var CodeString = class CodeString {
+	constructor(str) {
+		this.ref = { str: "" };
+		if (str instanceof CodeString) {
+			this.ref = str.ref;
+			this.start = str.start;
+			this.end = str.end;
+		} else {
+			this.ref.str = str;
+			this.start = 0;
+			this.end = str.length;
+		}
+	}
+	substring(start, end) {
+		if (!this.length) return this;
+		start = this.start + start;
+		if (start < 0) start = 0;
+		if (start > this.end) start = this.end;
+		end = end === void 0 ? this.end : this.start + end;
+		if (end < 0) end = 0;
+		if (end > this.end) end = this.end;
+		const code = new CodeString(this);
+		code.start = start;
+		code.end = end;
+		return code;
+	}
+	get length() {
+		const len = this.end - this.start;
+		return len < 0 ? 0 : len;
+	}
+	char(i) {
+		if (this.start === this.end) return void 0;
+		return this.ref.str[this.start + i];
+	}
+	toString() {
+		return this.ref.str.substring(this.start, this.end);
+	}
+	trimStart() {
+		const found = /^\s+/.exec(this.toString());
+		const code = new CodeString(this);
+		if (found) code.start += found[0].length;
+		return code;
+	}
+	slice(start, end) {
+		if (start < 0) start = this.end - this.start + start;
+		if (start < 0) start = 0;
+		if (end === void 0) end = this.end - this.start;
+		if (end < 0) end = this.end - this.start + end;
+		if (end < 0) end = 0;
+		return this.substring(start, end);
+	}
+	trim() {
+		const code = this.trimStart();
+		const found = /\s+$/.exec(code.toString());
+		if (found) code.end -= found[0].length;
+		return code;
+	}
+	valueOf() {
+		return this.toString();
+	}
+};
+//#endregion
+exports.CodeString = CodeString;

package/dist/cjs/utils/ExecContext.d.ts

@@ -0,0 +1,34 @@
+import { IEvalContext } from '../eval';
+import { Change } from '../executor';
+import { IConstants, IExecutionTree, Lisp, LispItem } from '../parser';
+import { default as SandboxExec } from '../SandboxExec';
+import { IContext, IExecContext, IOptions, ISandboxGlobal, SandboxSymbolContext, SubscriptionSubject } from './types';
+export declare class ExecContext implements IExecContext {
+    ctx: IContext;
+    constants: IConstants;
+    tree: Lisp[];
+    getSubscriptions: Set<(obj: SubscriptionSubject, name: string) => void>;
+    setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
+    changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
+    setSubscriptionsGlobal: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
+    changeSubscriptionsGlobal: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
+    evals: Map<any, any>;
+    registerSandboxFunction: (fn: (...args: any[]) => any) => void;
+    allowJit: boolean;
+    evalContext?: IEvalContext | undefined;
+    constructor(ctx: IContext, constants: IConstants, tree: Lisp[], getSubscriptions: Set<(obj: SubscriptionSubject, name: string) => void>, setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>, changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>, setSubscriptionsGlobal: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>, changeSubscriptionsGlobal: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>, evals: Map<any, any>, registerSandboxFunction: (fn: (...args: any[]) => any) => void, allowJit: boolean, evalContext?: IEvalContext | undefined);
+}
+export declare function getSandboxSymbolCtor(symbols: SandboxSymbolContext): Function;
+interface SandboxGlobalConstructor {
+    new (): ISandboxGlobal;
+}
+export declare function sandboxedGlobal(globals: ISandboxGlobal): SandboxGlobalConstructor;
+export declare function createContext(sandbox: SandboxExec, options: IOptions): IContext;
+export declare function createExecContext(sandbox: {
+    readonly setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
+    readonly changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
+    readonly sandboxFunctions: WeakMap<(...args: any[]) => any, IExecContext>;
+    readonly context: IContext;
+}, executionTree: IExecutionTree, evalContext?: IEvalContext): IExecContext;
+export declare function isLisp<Type extends Lisp = Lisp>(item: LispItem | LispItem): item is Type;
+export {};

package/dist/cjs/utils/ExecContext.js

@@ -0,0 +1,171 @@
+const require_types = require("./types.js");
+const require_functionReplacements = require("./functionReplacements.js");
+const require_Prop = require("./Prop.js");
+const require_Scope = require("./Scope.js");
+//#region src/utils/ExecContext.ts
+var ExecContext = class {
+	constructor(ctx, constants, tree, getSubscriptions, setSubscriptions, changeSubscriptions, setSubscriptionsGlobal, changeSubscriptionsGlobal, evals, registerSandboxFunction, allowJit, evalContext) {
+		this.ctx = ctx;
+		this.constants = constants;
+		this.tree = tree;
+		this.getSubscriptions = getSubscriptions;
+		this.setSubscriptions = setSubscriptions;
+		this.changeSubscriptions = changeSubscriptions;
+		this.setSubscriptionsGlobal = setSubscriptionsGlobal;
+		this.changeSubscriptionsGlobal = changeSubscriptionsGlobal;
+		this.evals = evals;
+		this.registerSandboxFunction = registerSandboxFunction;
+		this.allowJit = allowJit;
+		this.evalContext = evalContext;
+	}
+};
+function createSandboxSymbolContext(symbolWhitelist) {
+	return {
+		registry: /* @__PURE__ */ new Map(),
+		reverseRegistry: /* @__PURE__ */ new Map(),
+		whitelist: { ...symbolWhitelist }
+	};
+}
+var RESERVED_SYMBOL_PROPERTIES = new Set([
+	"length",
+	"name",
+	"prototype",
+	"for",
+	"keyFor"
+]);
+function copyWhitelistedSymbols(target, symbolWhitelist) {
+	for (const [key, value] of Object.entries(symbolWhitelist)) {
+		if (RESERVED_SYMBOL_PROPERTIES.has(key)) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(Symbol, key);
+		if (descriptor) Object.defineProperty(target, key, descriptor);
+	}
+}
+function getSandboxSymbolCtor(symbols) {
+	if (symbols.ctor) return symbols.ctor;
+	function SandboxSymbol(description) {
+		if (new.target) throw new TypeError("Symbol is not a constructor");
+		return Symbol(description === void 0 ? void 0 : String(description));
+	}
+	copyWhitelistedSymbols(SandboxSymbol, symbols.whitelist);
+	Object.defineProperties(SandboxSymbol, {
+		prototype: {
+			value: Symbol.prototype,
+			enumerable: false,
+			configurable: false,
+			writable: false
+		},
+		for: {
+			value(key) {
+				const stringKey = String(key);
+				let symbol = symbols.registry.get(stringKey);
+				if (!symbol) {
+					symbol = Symbol(stringKey);
+					symbols.registry.set(stringKey, symbol);
+					symbols.reverseRegistry.set(symbol, stringKey);
+				}
+				return symbol;
+			},
+			enumerable: false,
+			configurable: true,
+			writable: true
+		},
+		keyFor: {
+			value(symbol) {
+				return typeof symbol === "symbol" ? symbols.reverseRegistry.get(symbol) : void 0;
+			},
+			enumerable: false,
+			configurable: true,
+			writable: true
+		}
+	});
+	symbols.ctor = SandboxSymbol;
+	return SandboxSymbol;
+}
+function SandboxGlobal() {}
+function sandboxedGlobal(globals) {
+	SG.prototype = SandboxGlobal.prototype;
+	return SG;
+	function SG() {
+		for (const i in globals) this[i] = globals[i];
+	}
+}
+function createContext(sandbox, options) {
+	const sandboxSymbols = createSandboxSymbolContext(options.symbolWhitelist);
+	const sandboxGlobal = new (sandboxedGlobal(options.globals))();
+	const context = {
+		sandbox,
+		globalsWhitelist: new Set(Object.values(options.globals)),
+		prototypeWhitelist: new Map([...options.prototypeWhitelist].map((a) => [a[0].prototype, a[1]])),
+		sandboxSymbols,
+		options,
+		globalScope: new require_Scope.Scope(null, sandboxGlobal, sandboxGlobal),
+		sandboxGlobal,
+		ticks: {
+			ticks: 0n,
+			tickLimit: options.executionQuota,
+			nextYield: options.nonBlocking ? require_types.NON_BLOCKING_THRESHOLD : void 0
+		},
+		sandboxedFunctions: /* @__PURE__ */ new WeakSet()
+	};
+	context.prototypeWhitelist.set(Object.getPrototypeOf(sandboxGlobal), /* @__PURE__ */ new Set());
+	context.prototypeWhitelist.set(Object.getPrototypeOf([][Symbol.iterator]()), /* @__PURE__ */ new Set());
+	const genProto = Object.getPrototypeOf((function* () {})());
+	context.prototypeWhitelist.set(Object.getPrototypeOf(genProto), /* @__PURE__ */ new Set());
+	const asyncGenProto = Object.getPrototypeOf((async function* () {})());
+	context.prototypeWhitelist.set(Object.getPrototypeOf(asyncGenProto), /* @__PURE__ */ new Set());
+	if (typeof Response !== "undefined") context.prototypeWhitelist.set(Response.prototype, /* @__PURE__ */ new Set());
+	if (typeof Request !== "undefined") context.prototypeWhitelist.set(Request.prototype, /* @__PURE__ */ new Set());
+	if (typeof Headers !== "undefined") context.prototypeWhitelist.set(Headers.prototype, /* @__PURE__ */ new Set());
+	if (typeof FormData !== "undefined") context.prototypeWhitelist.set(FormData.prototype, /* @__PURE__ */ new Set());
+	if (typeof Blob !== "undefined") context.prototypeWhitelist.set(Blob.prototype, /* @__PURE__ */ new Set());
+	if (typeof URLSearchParams !== "undefined") context.prototypeWhitelist.set(URLSearchParams.prototype, /* @__PURE__ */ new Set());
+	if (typeof AbortController !== "undefined") context.prototypeWhitelist.set(AbortController.prototype, /* @__PURE__ */ new Set());
+	if (typeof ReadableStream !== "undefined") context.prototypeWhitelist.set(ReadableStream.prototype, /* @__PURE__ */ new Set());
+	if (typeof TransformStream !== "undefined") context.prototypeWhitelist.set(TransformStream.prototype, /* @__PURE__ */ new Set());
+	if (typeof WritableStream !== "undefined") context.prototypeWhitelist.set(WritableStream.prototype, /* @__PURE__ */ new Set());
+	if (typeof TextEncoder !== "undefined") context.prototypeWhitelist.set(TextEncoder.prototype, /* @__PURE__ */ new Set());
+	if (typeof TextDecoder !== "undefined") context.prototypeWhitelist.set(TextDecoder.prototype, /* @__PURE__ */ new Set());
+	return context;
+}
+function createExecContext(sandbox, executionTree, evalContext) {
+	const evals = /* @__PURE__ */ new Map();
+	const execContext = new ExecContext(sandbox.context, executionTree.constants, executionTree.tree, /* @__PURE__ */ new Set(), /* @__PURE__ */ new WeakMap(), /* @__PURE__ */ new WeakMap(), sandbox.setSubscriptions, sandbox.changeSubscriptions, evals, (fn) => sandbox.sandboxFunctions.set(fn, execContext), !!evalContext, evalContext);
+	if (evalContext) {
+		const func = evalContext.sandboxFunction(execContext);
+		const asyncFunc = evalContext.sandboxAsyncFunction(execContext);
+		const genFunc = evalContext.sandboxGeneratorFunction(execContext);
+		const asyncGenFunc = evalContext.sandboxAsyncGeneratorFunction(execContext);
+		const sandboxSymbol = evalContext.sandboxedSymbol(execContext);
+		evals.set(Function, func);
+		evals.set(require_types.AsyncFunction, asyncFunc);
+		evals.set(require_types.GeneratorFunction, genFunc);
+		evals.set(require_types.AsyncGeneratorFunction, asyncGenFunc);
+		evals.set(Symbol, sandboxSymbol);
+		evals.set(eval, evalContext.sandboxedEval(func, execContext));
+		evals.set(setTimeout, evalContext.sandboxedSetTimeout(func, execContext));
+		evals.set(setInterval, evalContext.sandboxedSetInterval(func, execContext));
+		evals.set(clearTimeout, evalContext.sandboxedClearTimeout(execContext));
+		evals.set(clearInterval, evalContext.sandboxedClearInterval(execContext));
+		for (const [original, factory] of require_functionReplacements.DEFAULT_FUNCTION_REPLACEMENTS) evals.set(original, factory(execContext));
+		for (const [original, factory] of sandbox.context.options.functionReplacements) evals.set(original, factory(execContext, evals.get(original)));
+		const ptwl = sandbox.context.prototypeWhitelist;
+		for (const [key, value] of evals) {
+			if (!ptwl.has(key.prototype)) ptwl.set(key.prototype, /* @__PURE__ */ new Set());
+			if (!ptwl.has(value.prototype)) ptwl.set(value.prototype, ptwl.get(key.prototype) || /* @__PURE__ */ new Set());
+			if (sandbox.context.globalsWhitelist.has(key)) sandbox.context.globalsWhitelist.add(value);
+			if (require_Prop.hasOwnProperty(sandbox.context.sandboxGlobal, key.name)) sandbox.context.sandboxGlobal[key.name] = value;
+		}
+		if (sandbox.context.sandboxGlobal.globalThis) sandbox.context.sandboxGlobal.globalThis = sandbox.context.sandboxGlobal;
+	}
+	return execContext;
+}
+function isLisp(item) {
+	return Array.isArray(item) && typeof item[0] === "number" && item[0] !== require_types.LispType.None && item[0] !== require_types.LispType.True;
+}
+//#endregion
+exports.ExecContext = ExecContext;
+exports.createContext = createContext;
+exports.createExecContext = createExecContext;
+exports.getSandboxSymbolCtor = getSandboxSymbolCtor;
+exports.isLisp = isLisp;
+exports.sandboxedGlobal = sandboxedGlobal;

package/dist/cjs/utils/Prop.d.ts

@@ -0,0 +1,16 @@
+import { IExecContext } from './types';
+export declare class Prop<T = unknown> {
+    context: T;
+    prop: PropertyKey;
+    isConst: boolean;
+    isGlobal: boolean;
+    isVariable: boolean;
+    isInternal: boolean;
+    constructor(context: T, prop: PropertyKey, isConst?: boolean, isGlobal?: boolean, isVariable?: boolean, isInternal?: boolean);
+    get<T = unknown>(context: IExecContext): T;
+}
+export declare function hasOwnProperty(obj: unknown, prop: PropertyKey): boolean;
+export declare function getReplacementReceiver(fn: Function): object | undefined;
+export declare function resolveSandboxProp(val: unknown, context: IExecContext, prop?: Prop): Prop<{
+    [x: string]: unknown;
+}> | undefined;

package/dist/cjs/utils/Prop.js

@@ -0,0 +1,81 @@
+const require_functionReplacements = require("./functionReplacements.js");
+//#region src/utils/Prop.ts
+var boundFunctionCache = /* @__PURE__ */ new WeakMap();
+var replacementReceiver = /* @__PURE__ */ new WeakMap();
+var Prop = class {
+	constructor(context, prop, isConst = false, isGlobal = false, isVariable = false, isInternal = false) {
+		this.context = context;
+		this.prop = prop;
+		this.isConst = isConst;
+		this.isGlobal = isGlobal;
+		this.isVariable = isVariable;
+		this.isInternal = isInternal;
+	}
+	get(context) {
+		const ctx = this.context;
+		if (ctx === void 0) throw new ReferenceError(`${this.prop.toString()} is not defined`);
+		if (ctx === null) throw new TypeError(`Cannot read properties of null, (reading '${this.prop.toString()}')`);
+		context.getSubscriptions.forEach((cb) => cb(ctx, this.prop.toString()));
+		const val = ctx[this.prop];
+		return getReplacementValue(val, context, ctx);
+	}
+};
+function hasOwnProperty(obj, prop) {
+	return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function getReplacementReceiver(fn) {
+	return replacementReceiver.get(fn);
+}
+function resolveSandboxProp(val, context, prop) {
+	if (!val) return;
+	if (val instanceof Prop) {
+		if (!prop) prop = val;
+		val = val.get(context);
+	}
+	const p = prop?.prop || "prop";
+	if (val === globalThis) return new Prop({ [p]: context.ctx.sandboxGlobal }, p, prop?.isConst || false, false, prop?.isVariable || false);
+	if (prop && !prop.isVariable) return;
+	const replacement = getReplacementValue(val, context, prop?.context);
+	if (replacement !== val) return new Prop({ [p]: replacement }, p, prop?.isConst || false, prop?.isGlobal || false, prop?.isVariable || false);
+}
+function getReplacementValue(val, context, bindContext) {
+	if (typeof val !== "function") return val;
+	const replacement = context.evals.get(val);
+	if (replacement === void 0) return val;
+	if (!shouldBindReplacement(val, bindContext, context)) return replacement;
+	return bindReplacement(replacement, bindContext, val, context);
+}
+function shouldBindReplacement(original, bindContext, context) {
+	return require_functionReplacements.THIS_DEPENDENT_FUNCTION_REPLACEMENTS.has(original) && bindContext !== null && (typeof bindContext === "object" || typeof bindContext === "function") && bindContext !== context.ctx.sandboxGlobal && !context.ctx.globalsWhitelist.has(bindContext);
+}
+function bindReplacement(replacement, bindContext, original, context) {
+	let cache = boundFunctionCache.get(replacement);
+	if (!cache) {
+		cache = /* @__PURE__ */ new WeakMap();
+		boundFunctionCache.set(replacement, cache);
+	}
+	let bound = cache.get(bindContext);
+	if (bound) return bound;
+	bound = function(...args) {
+		return replacement.apply(this, args);
+	};
+	redefineFunctionMetadata(bound, original);
+	context.ctx.sandboxedFunctions.add(bound);
+	replacementReceiver.set(bound, bindContext);
+	cache.set(bindContext, bound);
+	return bound;
+}
+function redefineFunctionMetadata(target, source, overrides = {}) {
+	for (const key of ["name", "length"]) {
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor?.configurable) Object.defineProperty(target, key, {
+			...descriptor,
+			value: overrides[key] ?? source[key]
+		});
+	}
+}
+//#endregion
+exports.Prop = Prop;
+exports.getReplacementReceiver = getReplacementReceiver;
+exports.hasOwnProperty = hasOwnProperty;
+exports.resolveSandboxProp = resolveSandboxProp;

package/dist/cjs/utils/Scope.d.ts

@@ -0,0 +1,47 @@
+import { VarType, IExecContext, IScope } from './types';
+import { Prop } from './Prop';
+export type Unknown = undefined | null | Record<string | number, unknown>;
+export declare class Scope {
+    parent: Scope | null;
+    const: {
+        [key: string]: true;
+    };
+    let: {
+        [key: string]: true;
+    };
+    var: {
+        [key: string]: true;
+    };
+    internal: {
+        [key: string]: true;
+    };
+    globals: {
+        [key: string]: true;
+    };
+    allVars: {
+        [key: string]: unknown;
+    } & object;
+    internalVars: {
+        [key: string]: unknown;
+    };
+    functionThis?: Unknown;
+    constructor(parent: Scope | null, vars?: {}, functionThis?: Unknown);
+    get(key: string, internal: boolean): Prop;
+    set(key: string, val: unknown, internal: boolean): Prop<unknown>;
+    getWhereValScope(key: string, isThis: boolean, internal: boolean): Scope | null;
+    getWhereVarScope(key: string, localScope: boolean, internal: boolean): Scope;
+    declare(key: string, type: VarType, value: unknown, isGlobal: boolean, internal: boolean): Prop;
+}
+export declare class FunctionScope implements IScope {
+}
+export declare class LocalScope implements IScope {
+}
+export declare const optional: {};
+export declare class DelayedSynchronousResult {
+    readonly result: unknown;
+    constructor(cb: () => unknown);
+}
+export declare function delaySynchronousResult(cb: () => Promise<unknown>): DelayedSynchronousResult;
+export declare function sanitizeProp(value: unknown, context: IExecContext, cache?: WeakSet<object>): unknown;
+export declare function sanitizeScope(scope: IScope, context: IExecContext, cache?: WeakSet<object>): void;
+export declare function sanitizeScopes(scopes: IScope[], context: IExecContext, cache?: WeakSet<object>): void;

package/dist/cjs/utils/Scope.js

@@ -0,0 +1,127 @@
+const require_errors = require("./errors.js");
+const require_types = require("./types.js");
+const require_Prop = require("./Prop.js");
+//#region src/utils/Scope.ts
+function keysOnly(obj) {
+	const ret = Object.assign({}, obj);
+	for (const key in ret) ret[key] = true;
+	return ret;
+}
+var Scope = class {
+	constructor(parent, vars = {}, functionThis) {
+		this.const = {};
+		this.let = {};
+		this.var = {};
+		this.internal = {};
+		this.internalVars = {};
+		const isFuncScope = functionThis !== void 0 || parent === null;
+		this.parent = parent;
+		this.allVars = vars;
+		this.let = isFuncScope ? this.let : keysOnly(vars);
+		this.var = isFuncScope ? keysOnly(vars) : this.var;
+		this.globals = parent === null ? keysOnly(vars) : {};
+		this.functionThis = functionThis;
+	}
+	get(key, internal) {
+		const isThis = key === "this";
+		const scope = this.getWhereValScope(key, isThis, internal);
+		if (scope && isThis) return new require_Prop.Prop({ this: scope.functionThis }, key, false, false, true);
+		if (!scope) return new require_Prop.Prop(void 0, key);
+		if (internal && scope.internalVars[key]) return new require_Prop.Prop(scope.internalVars, key, false, false, true, true);
+		return new require_Prop.Prop(scope.allVars, key, require_Prop.hasOwnProperty(scope.const, key), require_Prop.hasOwnProperty(scope.globals, key), true);
+	}
+	set(key, val, internal) {
+		if (key === "this") throw new SyntaxError("\"this\" cannot be assigned");
+		if (require_types.reservedWords.has(key)) throw new SyntaxError("Unexepected token '" + key + "'");
+		const prop = this.get(key, internal);
+		if (prop.context === void 0) throw new ReferenceError(`Variable '${key}' was not declared.`);
+		if (prop.context === null) throw new TypeError(`Cannot set properties of null, (setting '${key}')`);
+		if (prop.isConst) throw new TypeError(`Assignment to constant variable`);
+		if (prop.isGlobal) throw new require_errors.SandboxError(`Cannot override global variable '${key}'`);
+		prop.context[prop.prop] = val;
+		return prop;
+	}
+	getWhereValScope(key, isThis, internal) {
+		let scope = this;
+		if (isThis) {
+			do {
+				if (scope.functionThis !== void 0) return scope;
+				scope = scope.parent;
+			} while (scope !== null);
+			return null;
+		}
+		do {
+			if (internal && key in scope.internalVars && !(key in {} && !require_Prop.hasOwnProperty(scope.internalVars, key))) return scope;
+			if (key in scope.allVars && !(key in {} && !require_Prop.hasOwnProperty(scope.allVars, key))) return scope;
+			scope = scope.parent;
+		} while (scope !== null);
+		return null;
+	}
+	getWhereVarScope(key, localScope, internal) {
+		let scope = this;
+		do {
+			if (internal && key in scope.internalVars && !(key in {} && !require_Prop.hasOwnProperty(scope.internalVars, key))) return scope;
+			if (key in scope.allVars && !(key in {} && !require_Prop.hasOwnProperty(scope.allVars, key))) return scope;
+			if (scope.parent === null || localScope || scope.functionThis !== void 0) return scope;
+			scope = scope.parent;
+		} while (scope !== null);
+		return scope;
+	}
+	declare(key, type, value, isGlobal, internal) {
+		if (key === "this") throw new SyntaxError("\"this\" cannot be declared");
+		if (require_types.reservedWords.has(key)) throw new SyntaxError("Unexepected token '" + key + "'");
+		const existingScope = this.getWhereVarScope(key, type !== require_types.VarType.var, internal);
+		if (type === require_types.VarType.var) {
+			if (existingScope.var[key]) {
+				existingScope.allVars[key] = value;
+				if (!isGlobal) delete existingScope.globals[key];
+				else existingScope.globals[key] = true;
+				return new require_Prop.Prop(existingScope.allVars, key, false, existingScope.globals[key], true);
+			} else if (key in existingScope.allVars) throw new SyntaxError(`Identifier '${key}' has already been declared`);
+		}
+		if (key in existingScope.allVars || key in existingScope.internalVars) throw new SyntaxError(`Identifier '${key}' has already been declared`);
+		if (isGlobal) existingScope.globals[key] = true;
+		existingScope[type][key] = true;
+		if (type === require_types.VarType.internal) existingScope.internalVars[key] = value;
+		else existingScope.allVars[key] = value;
+		return new require_Prop.Prop(type === require_types.VarType.internal ? this.internalVars : this.allVars, key, type === require_types.VarType.const, isGlobal, true, type === require_types.VarType.internal);
+	}
+};
+var LocalScope = class {};
+var optional = {};
+var DelayedSynchronousResult = class {
+	constructor(cb) {
+		this.result = cb();
+	}
+};
+function delaySynchronousResult(cb) {
+	return new DelayedSynchronousResult(cb);
+}
+function sanitizeProp(value, context, cache = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return value;
+	value = require_Prop.resolveSandboxProp(value, context) || value;
+	if (value instanceof require_Prop.Prop) value = value.get(context);
+	if (value === optional) return;
+	return value;
+}
+function sanitizeScope(scope, context, cache = /* @__PURE__ */ new WeakSet()) {
+	if (cache.has(scope)) return;
+	cache.add(scope);
+	for (const key in scope) {
+		const val = scope[key];
+		if (val !== null && typeof val === "object") sanitizeScope(val, context, cache);
+		scope[key] = sanitizeProp(val, context);
+	}
+}
+function sanitizeScopes(scopes, context, cache = /* @__PURE__ */ new WeakSet()) {
+	for (const scope of scopes) sanitizeScope(scope, context, cache);
+}
+//#endregion
+exports.DelayedSynchronousResult = DelayedSynchronousResult;
+exports.LocalScope = LocalScope;
+exports.Scope = Scope;
+exports.delaySynchronousResult = delaySynchronousResult;
+exports.optional = optional;
+exports.sanitizeProp = sanitizeProp;
+exports.sanitizeScope = sanitizeScope;
+exports.sanitizeScopes = sanitizeScopes;

package/dist/cjs/utils/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class SandboxError extends Error {
+}
+export declare class SandboxExecutionQuotaExceededError extends SandboxError {
+}
+export declare class SandboxExecutionTreeError extends SandboxError {
+}
+export declare class SandboxCapabilityError extends SandboxError {
+}
+export declare class SandboxAccessError extends SandboxError {
+}

package/dist/cjs/utils/errors.js

@@ -0,0 +1,12 @@
+//#region src/utils/errors.ts
+var SandboxError = class extends Error {};
+var SandboxExecutionQuotaExceededError = class extends SandboxError {};
+var SandboxExecutionTreeError = class extends SandboxError {};
+var SandboxCapabilityError = class extends SandboxError {};
+var SandboxAccessError = class extends SandboxError {};
+//#endregion
+exports.SandboxAccessError = SandboxAccessError;
+exports.SandboxCapabilityError = SandboxCapabilityError;
+exports.SandboxError = SandboxError;
+exports.SandboxExecutionQuotaExceededError = SandboxExecutionQuotaExceededError;
+exports.SandboxExecutionTreeError = SandboxExecutionTreeError;

package/dist/cjs/utils/functionReplacements.d.ts

@@ -0,0 +1,11 @@
+import { IExecContext } from './types';
+/**
+ * Checks if adding `expectTicks` would exceed the tick limit, and throws SandboxExecutionQuotaExceededError
+ * (which bypasses user try/catch) if so. Otherwise increments the tick counter.
+ */
+export declare function checkTicksAndThrow(ctx: IExecContext, expectTicks: bigint): void;
+export declare const typedArrayProtos: Set<any>;
+type Factory = (ctx: IExecContext) => Function;
+export declare const DEFAULT_FUNCTION_REPLACEMENTS: Map<Function, Factory>;
+export declare const THIS_DEPENDENT_FUNCTION_REPLACEMENTS: Set<Function>;
+export {};