@nyariv/sandboxjs 0.8.22 → 0.8.24

package/build/unraw.js

@@ -23,8 +23,7 @@ function parseHexToInt(hex) {
  */
 function validateAndParseHex(hex, errorName, enforcedLength) {
     const parsedHex = parseHexToInt(hex);
-    if (Number.isNaN(parsedHex) ||
-        (enforcedLength !== undefined && enforcedLength !== hex.length)) {
+    if (Number.isNaN(parsedHex) || (enforcedLength !== undefined && enforcedLength !== hex.length)) {
         throw new SyntaxError(errorName + ': ' + hex);
     }
     return parsedHex;
@@ -65,7 +64,7 @@ function parseUnicodeCode(code, surrogateCode) {
  * @returns `true` if the text is in the form `{*}`.
  */
 function isCurlyBraced(text) {
-    return text.charAt(0) === "{" && text.charAt(text.length - 1) === "}";
+    return text.charAt(0) === '{' && text.charAt(text.length - 1) === '}';
 }
 /**
  * Parse a Unicode code point character escape code.
@@ -85,9 +84,7 @@ function parseUnicodeCodePointCode(codePoint) {
         return String.fromCodePoint(parsedCode);
     }
     catch (err) {
-        throw err instanceof RangeError
-            ? new SyntaxError('Code Point Limit:' + parsedCode)
-            : err;
+        throw err instanceof RangeError ? new SyntaxError('Code Point Limit:' + parsedCode) : err;
     }
 }
 /**
@@ -95,13 +92,13 @@ function parseUnicodeCodePointCode(codePoint) {
  * Intentionally does not include characters that map to themselves like "\'".
  */
 const singleCharacterEscapes = new Map([
-    ["b", "\b"],
-    ["f", "\f"],
-    ["n", "\n"],
-    ["r", "\r"],
-    ["t", "\t"],
-    ["v", "\v"],
-    ["0", "\0"]
+    ['b', '\b'],
+    ['f', '\f'],
+    ['n', '\n'],
+    ['r', '\r'],
+    ['t', '\t'],
+    ['v', '\v'],
+    ['0', '\0'],
 ]);
 /**
  * Parse a single character escape sequence and return the matching character.
@@ -142,7 +139,7 @@ export function unraw(raw) {
         // Compare groups to undefined because empty strings mean different errors
         // Otherwise, `\u` would fail the same as `\` which is wrong.
         if (backslash !== undefined) {
-            return "\\";
+            return '\\';
         }
         if (hex !== undefined) {
             return parseHexadecimalCode(hex);
@@ -156,8 +153,8 @@ export function unraw(raw) {
         if (unicode !== undefined) {
             return parseUnicodeCode(unicode);
         }
-        if (octal === "0") {
-            return "\0";
+        if (octal === '0') {
+            return '\0';
         }
         if (octal !== undefined) {
             throw new SyntaxError('Octal Deprecation: ' + octal);

package/build/utils.d.ts

@@ -0,0 +1,242 @@
+import { IEvalContext } from './eval';
+import { Change, Unknown } from './executor';
+import { IConstants, IExecutionTree, Lisp, LispItem } from './parser';
+import SandboxExec from './SandboxExec';
+export type replacementCallback = (obj: any, isStaticAccess: boolean) => any;
+export interface IOptionParams {
+    audit?: boolean;
+    forbidFunctionCalls?: boolean;
+    forbidFunctionCreation?: boolean;
+    prototypeReplacements?: Map<new () => any, replacementCallback>;
+    prototypeWhitelist?: Map<any, Set<string>>;
+    globals: IGlobals;
+    executionQuota?: bigint;
+    onExecutionQuotaReached?: (ticks: Ticks, scope: Scope, context: IExecutionTree, tree: LispItem) => boolean | void;
+}
+export interface IOptions {
+    audit: boolean;
+    forbidFunctionCalls: boolean;
+    forbidFunctionCreation: boolean;
+    prototypeReplacements: Map<new () => any, replacementCallback>;
+    prototypeWhitelist: Map<any, Set<string>>;
+    globals: IGlobals;
+    executionQuota?: bigint;
+    onExecutionQuotaReached?: (ticks: Ticks, scope: Scope, context: IExecutionTree, tree: LispItem) => boolean | void;
+}
+export interface IContext {
+    sandbox: SandboxExec;
+    globalScope: Scope;
+    sandboxGlobal: ISandboxGlobal;
+    globalsWhitelist: Set<any>;
+    prototypeWhitelist: Map<any, Set<string>>;
+    options: IOptions;
+    auditReport?: IAuditReport;
+}
+export interface IAuditReport {
+    globalsAccess: Set<unknown>;
+    prototypeAccess: {
+        [name: string]: Set<string>;
+    };
+}
+export interface Ticks {
+    ticks: bigint;
+}
+export type SubscriptionSubject = object;
+export interface IExecContext extends IExecutionTree {
+    ctx: IContext;
+    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>>;
+    registerSandboxFunction: (fn: (...args: any[]) => any) => void;
+    evals: Map<any, any>;
+    allowJit: boolean;
+    evalContext?: IEvalContext;
+}
+export interface ISandboxGlobal {
+    [key: string]: unknown;
+}
+interface SandboxGlobalConstructor {
+    new (globals: IGlobals): ISandboxGlobal;
+}
+export declare const SandboxGlobal: SandboxGlobalConstructor;
+export type IGlobals = ISandboxGlobal;
+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 createContext(sandbox: SandboxExec, options: IOptions): IContext;
+export declare function createExecContext(sandbox: {
+    setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
+    changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
+    sandboxFunctions: WeakMap<(...args: any[]) => any, IExecContext>;
+    context: IContext;
+}, executionTree: IExecutionTree, evalContext?: IEvalContext): IExecContext;
+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;
+}
+export declare const enum VarType {
+    let = "let",
+    const = "const",
+    var = "var"
+}
+export declare class Scope {
+    parent: Scope | null;
+    const: {
+        [key: string]: true;
+    };
+    let: {
+        [key: string]: true;
+    };
+    var: {
+        [key: string]: true;
+    };
+    globals: {
+        [key: string]: true;
+    };
+    allVars: {
+        [key: string]: unknown;
+    } & Object;
+    functionThis?: Unknown;
+    constructor(parent: Scope | null, vars?: {}, functionThis?: Unknown);
+    get(key: string, functionScope?: boolean): Prop;
+    set(key: string, val: unknown): Prop;
+    declare(key: string, type: VarType, value?: unknown, isGlobal?: boolean): Prop;
+}
+export interface IScope {
+    [key: string]: any;
+}
+export declare class FunctionScope implements IScope {
+}
+export declare class LocalScope implements IScope {
+}
+export declare class SandboxError extends Error {
+}
+export declare function isLisp<Type extends Lisp = Lisp>(item: LispItem | LispItem): item is Type;
+export declare const enum LispType {
+    None = 0,
+    Prop = 1,
+    StringIndex = 2,
+    Let = 3,
+    Const = 4,
+    Call = 5,
+    KeyVal = 6,
+    Number = 7,
+    Return = 8,
+    Assign = 9,
+    InlineFunction = 10,
+    ArrowFunction = 11,
+    CreateArray = 12,
+    If = 13,
+    IfCase = 14,
+    InlineIf = 15,
+    InlineIfCase = 16,
+    SpreadObject = 17,
+    SpreadArray = 18,
+    ArrayProp = 19,
+    PropOptional = 20,
+    CallOptional = 21,
+    CreateObject = 22,
+    Group = 23,
+    Not = 24,
+    IncrementBefore = 25,
+    IncrementAfter = 26,
+    DecrementBefore = 27,
+    DecrementAfter = 28,
+    And = 29,
+    Or = 30,
+    StrictNotEqual = 31,
+    StrictEqual = 32,
+    Plus = 33,
+    Var = 34,
+    GlobalSymbol = 35,
+    Literal = 36,
+    Function = 37,
+    Loop = 38,
+    Try = 39,
+    Switch = 40,
+    SwitchCase = 41,
+    Block = 42,
+    Expression = 43,
+    Await = 44,
+    New = 45,
+    Throw = 46,
+    Minus = 47,
+    Divide = 48,
+    Power = 49,
+    Multiply = 50,
+    Modulus = 51,
+    Equal = 52,
+    NotEqual = 53,
+    SmallerEqualThan = 54,
+    LargerEqualThan = 55,
+    SmallerThan = 56,
+    LargerThan = 57,
+    Negative = 58,
+    Positive = 59,
+    Typeof = 60,
+    Delete = 61,
+    Instanceof = 62,
+    In = 63,
+    Inverse = 64,
+    SubractEquals = 65,
+    AddEquals = 66,
+    DivideEquals = 67,
+    PowerEquals = 68,
+    MultiplyEquals = 69,
+    ModulusEquals = 70,
+    BitNegateEquals = 71,
+    BitAndEquals = 72,
+    BitOrEquals = 73,
+    UnsignedShiftRightEquals = 74,
+    ShiftRightEquals = 75,
+    ShiftLeftEquals = 76,
+    BitAnd = 77,
+    BitOr = 78,
+    BitNegate = 79,
+    BitShiftLeft = 80,
+    BitShiftRight = 81,
+    BitUnsignedShiftRight = 82,
+    BigInt = 83,
+    LiteralIndex = 84,
+    RegexIndex = 85,
+    LoopAction = 86,
+    Void = 87,
+    True = 88,
+    LispEnumSize = 89
+}
+export declare class Prop {
+    context: Unknown;
+    prop: string;
+    isConst: boolean;
+    isGlobal: boolean;
+    isVariable: boolean;
+    constructor(context: Unknown, prop: string, isConst?: boolean, isGlobal?: boolean, isVariable?: boolean);
+    get<T = unknown>(context: IExecContext): T;
+}
+export {};

package/build/utils.js

@@ -0,0 +1,276 @@
+export const SandboxGlobal = function SandboxGlobal(globals) {
+    if (globals === globalThis)
+        return globalThis;
+    for (const i in globals) {
+        this[i] = globals[i];
+    }
+};
+export class ExecContext {
+    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;
+    }
+}
+export function createContext(sandbox, options) {
+    const sandboxGlobal = new SandboxGlobal(options.globals);
+    const context = {
+        sandbox: sandbox,
+        globalsWhitelist: new Set(Object.values(options.globals)),
+        prototypeWhitelist: new Map([...options.prototypeWhitelist].map((a) => [a[0].prototype, a[1]])),
+        options,
+        globalScope: new Scope(null, options.globals, sandboxGlobal),
+        sandboxGlobal,
+    };
+    context.prototypeWhitelist.set(Object.getPrototypeOf([][Symbol.iterator]()), new Set());
+    return context;
+}
+export function createExecContext(sandbox, executionTree, evalContext) {
+    const evals = new Map();
+    const execContext = new ExecContext(sandbox.context, executionTree.constants, executionTree.tree, new Set(), new WeakMap(), new WeakMap(), sandbox.setSubscriptions, sandbox.changeSubscriptions, evals, (fn) => sandbox.sandboxFunctions.set(fn, execContext), !!evalContext, evalContext);
+    if (evalContext) {
+        const func = evalContext.sandboxFunction(execContext);
+        evals.set(Function, func);
+        evals.set(eval, evalContext.sandboxedEval(func));
+        evals.set(setTimeout, evalContext.sandboxedSetTimeout(func));
+        evals.set(setInterval, evalContext.sandboxedSetInterval(func));
+    }
+    return execContext;
+}
+export 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 === undefined ? 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 undefined;
+        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 === undefined) {
+            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();
+    }
+}
+function keysOnly(obj) {
+    const ret = Object.assign({}, obj);
+    for (const key in ret) {
+        ret[key] = true;
+    }
+    return ret;
+}
+const reservedWords = new Set([
+    'instanceof',
+    'typeof',
+    'return',
+    'throw',
+    'try',
+    'catch',
+    'if',
+    'finally',
+    'else',
+    'in',
+    'of',
+    'var',
+    'let',
+    'const',
+    'for',
+    'delete',
+    'false',
+    'true',
+    'while',
+    'do',
+    'break',
+    'continue',
+    'new',
+    'function',
+    'async',
+    'await',
+    'switch',
+    'case',
+]);
+export class Scope {
+    constructor(parent, vars = {}, functionThis) {
+        this.const = {};
+        this.let = {};
+        this.var = {};
+        const isFuncScope = functionThis !== undefined || 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, functionScope = false) {
+        const functionThis = this.functionThis;
+        if (key === 'this' && functionThis !== undefined) {
+            return new Prop({ this: functionThis }, key, true, false, true);
+        }
+        if (reservedWords.has(key))
+            throw new SyntaxError("Unexepected token '" + key + "'");
+        if (this.parent === null || !functionScope || functionThis !== undefined) {
+            if (this.globals.hasOwnProperty(key)) {
+                return new Prop(functionThis, key, false, true, true);
+            }
+            if (key in this.allVars && (!(key in {}) || this.allVars.hasOwnProperty(key))) {
+                return new Prop(this.allVars, key, this.const.hasOwnProperty(key), this.globals.hasOwnProperty(key), true);
+            }
+            if (this.parent === null) {
+                return new Prop(undefined, key);
+            }
+        }
+        return this.parent.get(key, functionScope);
+    }
+    set(key, val) {
+        if (key === 'this')
+            throw new SyntaxError('"this" cannot be assigned');
+        if (reservedWords.has(key))
+            throw new SyntaxError("Unexepected token '" + key + "'");
+        const prop = this.get(key);
+        if (prop.context === undefined) {
+            throw new ReferenceError(`Variable '${key}' was not declared.`);
+        }
+        if (prop.isConst) {
+            throw new TypeError(`Cannot assign to const variable '${key}'`);
+        }
+        if (prop.isGlobal) {
+            throw new SandboxError(`Cannot override global variable '${key}'`);
+        }
+        if (!(prop.context instanceof Object))
+            throw new SandboxError('Scope is not an object');
+        prop.context[prop.prop] = val;
+        return prop;
+    }
+    declare(key, type, value = undefined, isGlobal = false) {
+        if (key === 'this')
+            throw new SyntaxError('"this" cannot be declared');
+        if (reservedWords.has(key))
+            throw new SyntaxError("Unexepected token '" + key + "'");
+        if (type === 'var' && this.functionThis === undefined && this.parent !== null) {
+            return this.parent.declare(key, type, value, isGlobal);
+        }
+        else if ((this[type].hasOwnProperty(key) && type !== 'const' && !this.globals.hasOwnProperty(key)) ||
+            !(key in this.allVars)) {
+            if (isGlobal) {
+                this.globals[key] = true;
+            }
+            this[type][key] = true;
+            this.allVars[key] = value;
+        }
+        else {
+            throw new SandboxError(`Identifier '${key}' has already been declared`);
+        }
+        return new Prop(this.allVars, key, this.const.hasOwnProperty(key), isGlobal);
+    }
+}
+export class FunctionScope {
+}
+export class LocalScope {
+}
+export class SandboxError extends Error {
+}
+export function isLisp(item) {
+    return (Array.isArray(item) &&
+        typeof item[0] === 'number' &&
+        item[0] !== 0 /* LispType.None */ &&
+        item[0] !== 88 /* LispType.True */);
+}
+export class Prop {
+    constructor(context, prop, isConst = false, isGlobal = false, isVariable = false) {
+        this.context = context;
+        this.prop = prop;
+        this.isConst = isConst;
+        this.isGlobal = isGlobal;
+        this.isVariable = isVariable;
+    }
+    get(context) {
+        const ctx = this.context;
+        if (ctx === undefined)
+            throw new ReferenceError(`${this.prop} is not defined`);
+        if (ctx === null)
+            throw new TypeError(`Cannot read properties of null, (reading '${this.prop}')`);
+        context.getSubscriptions.forEach((cb) => cb(ctx, this.prop));
+        return ctx[this.prop];
+    }
+}

package/dist/Sandbox.d.ts

@@ -1,90 +1,23 @@
-import { IGlobals, replacementCallback, IAuditReport, Change, ExecReturn, executeTree, executeTreeAsync, ops, assignCheck, execMany, execAsync, execSync, asyncDone, Scope, IScope, FunctionScope, LocalScope, syncDone } from "./executor.js";
-import { IExecutionTree, expectTypes, setLispType, LispItem, LispArray, IConstants } from "./parser.js";
-export { expectTypes, setLispType, ops as executionOps, assignCheck, execMany, execAsync, execSync, asyncDone, syncDone, executeTree, executeTreeAsync, FunctionScope, LocalScope, };
-export interface IOptions {
-    audit?: boolean;
-    forbidFunctionCalls?: boolean;
-    forbidFunctionCreation?: boolean;
-    prototypeReplacements?: Map<new () => any, replacementCallback>;
-    prototypeWhitelist?: Map<any, Set<string>>;
-    globals: IGlobals;
-    executionQuota?: bigint;
-    onExecutionQuotaReached?: (ticks: Ticks, scope: Scope, context: IExecutionTree, tree: LispItem) => boolean | void;
-}
-export interface IContext {
-    sandbox: Sandbox;
-    globalScope: Scope;
-    sandboxGlobal: SandboxGlobal;
-    globalsWhitelist?: Set<any>;
-    prototypeWhitelist?: Map<any, Set<string>>;
-    options: IOptions;
-    auditReport?: IAuditReport;
-}
-export interface Ticks {
-    ticks: bigint;
-}
-export interface IExecContext extends IExecutionTree {
-    ctx: IContext;
-    getSubscriptions: Set<(obj: object, name: string) => void>;
-    setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;
-    changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>;
-    setSubscriptionsGlobal: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;
-    changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>;
-    registerSandboxFunction: (fn: (...args: any[]) => any) => void;
-    evals: Map<any, any>;
-}
-export declare class SandboxGlobal {
-    constructor(globals: IGlobals);
-}
-export declare class ExecContext implements IExecContext {
-    ctx: IContext;
-    constants: IConstants;
-    tree: LispArray;
-    getSubscriptions: Set<(obj: object, name: string) => void>;
-    setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;
-    changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>;
-    setSubscriptionsGlobal: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;
-    changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>;
-    evals: Map<any, any>;
-    registerSandboxFunction: (fn: (...args: any[]) => any) => void;
-    constructor(ctx: IContext, constants: IConstants, tree: LispArray, getSubscriptions: Set<(obj: object, name: string) => void>, setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>, changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>, setSubscriptionsGlobal: WeakMap<object, Map<string, Set<(modification: Change) => void>>>, changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>, evals: Map<any, any>, registerSandboxFunction: (fn: (...args: any[]) => any) => void);
-}
-export default class Sandbox {
-    context: IContext;
-    setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;
-    changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>;
-    sandboxFunctions: WeakMap<(...args: any[]) => any, IExecContext>;
-    constructor(options?: IOptions);
-    static get SAFE_GLOBALS(): IGlobals;
-    static get SAFE_PROTOTYPES(): Map<any, Set<string>>;
-    subscribeGet(callback: (obj: object, name: string) => void, context: IExecContext): {
-        unsubscribe: () => void;
-    };
-    subscribeSet(obj: object, name: string, callback: (modification: Change) => void, context: Sandbox | IExecContext): {
-        unsubscribe: () => void;
-    };
-    subscribeSetGlobal(obj: object, name: string, callback: (modification: Change) => void): {
-        unsubscribe: () => void;
-    };
-    static audit<T>(code: string, scopes?: (IScope)[]): ExecReturn<T>;
-    static parse(code: string): IExecutionTree;
-    createContext(context: IContext, executionTree: IExecutionTree): any;
-    getContext(fn: (...args: any[]) => any): IExecContext;
-    executeTree<T>(context: IExecContext, scopes?: (IScope)[]): ExecReturn<T>;
-    executeTreeAsync<T>(context: IExecContext, scopes?: (IScope)[]): Promise<ExecReturn<T>>;
-    compile<T>(code: string, optimize?: boolean): (...scopes: (IScope)[]) => {
+import { IExecContext, IOptionParams, IScope } from './utils.js';
+import { ExecReturn } from './executor.js';
+import SandboxExec from './SandboxExec.js';
+export default class Sandbox extends SandboxExec {
+    constructor(options?: IOptionParams);
+    static audit<T>(code: string, scopes?: IScope[]): ExecReturn<T>;
+    static parse(code: string): import("./parser.js").IExecutionTree;
+    compile<T>(code: string, optimize?: boolean): (...scopes: IScope[]) => {
         context: IExecContext;
         run: () => T;
     };
-    compileAsync<T>(code: string, optimize?: boolean): (...scopes: (IScope)[]) => {
+    compileAsync<T>(code: string, optimize?: boolean): (...scopes: IScope[]) => {
         context: IExecContext;
         run: () => Promise<T>;
     };
-    compileExpression<T>(code: string, optimize?: boolean): (...scopes: (IScope)[]) => {
+    compileExpression<T>(code: string, optimize?: boolean): (...scopes: IScope[]) => {
         context: IExecContext;
         run: () => T;
     };
-    compileExpressionAsync<T>(code: string, optimize?: boolean): (...scopes: (IScope)[]) => {
+    compileExpressionAsync<T>(code: string, optimize?: boolean): (...scopes: IScope[]) => {
         context: IExecContext;
         run: () => Promise<T>;
     };