@nyariv/sandboxjs 0.8.22 → 0.8.24

package/.eslintignore

@@ -0,0 +1,6 @@
+node_modules
+dist
+build
+test
+.*
+*.json

package/.eslintrc.js

@@ -0,0 +1,22 @@
+module.exports = {
+  env: {
+    browser: true,
+    es2021: true,
+  },
+  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended', 'prettier'],
+  overrides: [],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint'],
+  rules: {
+    'no-prototype-builtins': 0,
+    '@typescript-eslint/no-explicit-any': 0,
+    '@typescript-eslint/ban-types': 0,
+    '@typescript-eslint/no-non-null-assertion': 0,
+    'no-cond-assign': 0,
+    'no-fallthrough': 0,
+  },
+};

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "printWidth": 100,
+  "singleQuote": true
+}

package/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true
+}

package/build/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>;
     };

package/build/Sandbox.js

@@ -1,246 +1,48 @@
-import { sandboxFunction, sandboxedEval, sandboxedSetTimeout, sandboxedSetInterval, executeTree, executeTreeAsync, ops, assignCheck, execMany, execAsync, execSync, asyncDone, Scope, FunctionScope, LocalScope, syncDone } from "./executor.js";
-import { parse, expectTypes, setLispType } from "./parser.js";
-export { expectTypes, setLispType, ops as executionOps, assignCheck, execMany, execAsync, execSync, asyncDone, syncDone, executeTree, executeTreeAsync, FunctionScope, LocalScope, };
-export class SandboxGlobal {
-    constructor(globals) {
-        if (globals === globalThis)
-            return globalThis;
-        for (let i in globals) {
-            this[i] = globals[i];
-        }
-    }
-}
-export class ExecContext {
-    constructor(ctx, constants, tree, getSubscriptions, setSubscriptions, changeSubscriptions, setSubscriptionsGlobal, changeSubscriptionsGlobal, evals, registerSandboxFunction) {
-        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;
-    }
-}
-function subscribeSet(obj, name, callback, context) {
-    const names = context.setSubscriptions.get(obj) || new Map();
-    context.setSubscriptions.set(obj, names);
-    const callbacks = names.get(name) || new Set();
-    names.set(name, callbacks);
-    callbacks.add(callback);
-    let changeCbs;
-    if (obj && obj[name] && typeof obj[name] === "object") {
-        changeCbs = context.changeSubscriptions.get(obj[name]) || new Set();
-        changeCbs.add(callback);
-        context.changeSubscriptions.set(obj[name], changeCbs);
-    }
-    return {
-        unsubscribe: () => {
-            callbacks.delete(callback);
-            changeCbs === null || changeCbs === void 0 ? void 0 : changeCbs.delete(callback);
-        }
-    };
-}
-export default class Sandbox {
+import { createExecContext } from './utils.js';
+import { createEvalContext } from './eval.js';
+import parse from './parser.js';
+import SandboxExec from './SandboxExec.js';
+export default class Sandbox extends SandboxExec {
     constructor(options) {
-        this.setSubscriptions = new WeakMap();
-        this.changeSubscriptions = new WeakMap();
-        this.sandboxFunctions = new WeakMap();
-        options = Object.assign({
-            audit: false,
-            forbidFunctionCalls: false,
-            forbidFunctionCreation: false,
-            globals: Sandbox.SAFE_GLOBALS,
-            prototypeWhitelist: Sandbox.SAFE_PROTOTYPES,
-            prototypeReplacements: new Map(),
-        }, options || {});
-        const sandboxGlobal = new SandboxGlobal(options.globals);
-        this.context = {
-            sandbox: this,
-            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
-        };
-        this.context.prototypeWhitelist.set(Object.getPrototypeOf([][Symbol.iterator]()), new Set());
-    }
-    static get SAFE_GLOBALS() {
-        return {
-            Function,
-            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_PROTOTYPES() {
-        let protos = [
-            SandboxGlobal,
-            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
-        ];
-        let map = new Map();
-        protos.forEach((proto) => {
-            map.set(proto, new Set());
-        });
-        map.set(Object, new Set([
-            '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);
+        super(options, createEvalContext());
     }
     static audit(code, scopes = []) {
         const globals = {};
-        for (let i of Object.getOwnPropertyNames(globalThis)) {
+        for (const i of Object.getOwnPropertyNames(globalThis)) {
             globals[i] = globalThis[i];
         }
-        const sandbox = new Sandbox({
+        const sandbox = new SandboxExec({
             globals,
             audit: true,
         });
-        return sandbox.executeTree(sandbox.createContext(sandbox.context, parse(code)), scopes);
+        return sandbox.executeTree(createExecContext(sandbox, parse(code, true), createEvalContext()), scopes);
     }
     static parse(code) {
         return parse(code);
     }
-    createContext(context, executionTree) {
-        const evals = new Map();
-        const execContext = new ExecContext(context, executionTree.constants, executionTree.tree, new Set(), new WeakMap(), new WeakMap(), this.setSubscriptions, this.changeSubscriptions, evals, (fn) => this.sandboxFunctions.set(fn, execContext));
-        const func = sandboxFunction(execContext);
-        evals.set(Function, func);
-        evals.set(eval, sandboxedEval(func));
-        evals.set(setTimeout, sandboxedSetTimeout(func));
-        evals.set(setInterval, sandboxedSetInterval(func));
-        return execContext;
-    }
-    getContext(fn) {
-        return this.sandboxFunctions.get(fn);
-    }
-    executeTree(context, scopes = []) {
-        return executeTree({
-            ticks: BigInt(0),
-        }, context, context.tree, scopes);
-    }
-    executeTreeAsync(context, scopes = []) {
-        return executeTreeAsync({
-            ticks: BigInt(0),
-        }, context, context.tree, scopes);
-    }
     compile(code, optimize = false) {
         const parsed = parse(code, optimize);
         const exec = (...scopes) => {
-            const context = this.createContext(this.context, parsed);
+            const context = createExecContext(this, parsed, this.evalContext);
             return { context, run: () => this.executeTree(context, [...scopes]).result };
         };
         return exec;
     }
-    ;
     compileAsync(code, optimize = false) {
         const parsed = parse(code, optimize);
         const exec = (...scopes) => {
-            const context = this.createContext(this.context, parsed);
-            return { context, run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result) };
+            const context = createExecContext(this, parsed, this.evalContext);
+            return {
+                context,
+                run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result),
+            };
         };
         return exec;
     }
-    ;
     compileExpression(code, optimize = false) {
         const parsed = parse(code, optimize, true);
         const exec = (...scopes) => {
-            const context = this.createContext(this.context, parsed);
+            const context = createExecContext(this, parsed, this.evalContext);
             return { context, run: () => this.executeTree(context, [...scopes]).result };
         };
         return exec;
@@ -248,8 +50,11 @@ export default class Sandbox {
     compileExpressionAsync(code, optimize = false) {
         const parsed = parse(code, optimize, true);
         const exec = (...scopes) => {
-            const context = this.createContext(this.context, parsed);
-            return { context, run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result) };
+            const context = createExecContext(this, parsed, this.evalContext);
+            return {
+                context,
+                run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result),
+            };
         };
         return exec;
     }

package/build/SandboxExec.d.ts

@@ -0,0 +1,25 @@
+import { IEvalContext } from './eval.js';
+import { Change, ExecReturn } from './executor.js';
+import { IContext, IExecContext, IGlobals, IOptionParams, IScope, SubscriptionSubject } from './utils.js';
+export default class SandboxExec {
+    evalContext?: IEvalContext | undefined;
+    context: IContext;
+    setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
+    changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
+    sandboxFunctions: WeakMap<(...args: any[]) => any, IExecContext>;
+    constructor(options?: IOptionParams, evalContext?: IEvalContext | undefined);
+    static get SAFE_GLOBALS(): IGlobals;
+    static get SAFE_PROTOTYPES(): Map<any, Set<string>>;
+    subscribeGet(callback: (obj: SubscriptionSubject, name: string) => void, context: IExecContext): {
+        unsubscribe: () => void;
+    };
+    subscribeSet(obj: object, name: string, callback: (modification: Change) => void, context: SandboxExec | IExecContext): {
+        unsubscribe: () => void;
+    };
+    subscribeSetGlobal(obj: SubscriptionSubject, name: string, callback: (modification: Change) => void): {
+        unsubscribe: () => 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>>;
+}

package/build/SandboxExec.js

@@ -0,0 +1,169 @@
+import { executeTree, executeTreeAsync } from './executor.js';
+import { createContext, SandboxGlobal, } from './utils.js';
+function subscribeSet(obj, name, callback, context) {
+    if (!(obj instanceof Object))
+        throw new Error('Invalid subscription object, got ' + (typeof obj === 'object' ? 'null' : typeof obj));
+    const names = context.setSubscriptions.get(obj) || new Map();
+    context.setSubscriptions.set(obj, names);
+    const callbacks = names.get(name) || new Set();
+    names.set(name, callbacks);
+    callbacks.add(callback);
+    let changeCbs;
+    const val = obj[name];
+    if (val instanceof Object) {
+        changeCbs = context.changeSubscriptions.get(val) || new Set();
+        changeCbs.add(callback);
+        context.changeSubscriptions.set(val, changeCbs);
+    }
+    return {
+        unsubscribe: () => {
+            callbacks.delete(callback);
+            changeCbs?.delete(callback);
+        },
+    };
+}
+export default class SandboxExec {
+    constructor(options, evalContext) {
+        this.evalContext = evalContext;
+        this.setSubscriptions = new WeakMap();
+        this.changeSubscriptions = new WeakMap();
+        this.sandboxFunctions = new WeakMap();
+        const opt = Object.assign({
+            audit: false,
+            forbidFunctionCalls: false,
+            forbidFunctionCreation: false,
+            globals: SandboxExec.SAFE_GLOBALS,
+            prototypeWhitelist: SandboxExec.SAFE_PROTOTYPES,
+            prototypeReplacements: new Map(),
+        }, options || {});
+        this.context = createContext(this, opt);
+    }
+    static get SAFE_GLOBALS() {
+        return {
+            Function,
+            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_PROTOTYPES() {
+        const protos = [
+            SandboxGlobal,
+            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,
+        ];
+        const map = new Map();
+        protos.forEach((proto) => {
+            map.set(proto, new Set());
+        });
+        map.set(Object, new Set([
+            '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);
+    }
+    getContext(fn) {
+        return this.sandboxFunctions.get(fn);
+    }
+    executeTree(context, scopes = []) {
+        return executeTree({
+            ticks: BigInt(0),
+        }, context, context.tree, scopes);
+    }
+    executeTreeAsync(context, scopes = []) {
+        return executeTreeAsync({
+            ticks: BigInt(0),
+        }, context, context.tree, scopes);
+    }
+}

package/build/eval.d.ts

@@ -0,0 +1,18 @@
+import { lispifyFunction } from './parser.js';
+import { IExecContext, Ticks } from './utils.js';
+export interface IEvalContext {
+    sandboxFunction: typeof sandboxFunction;
+    sandboxedEval: typeof sandboxedEval;
+    sandboxedSetTimeout: typeof sandboxedSetTimeout;
+    sandboxedSetInterval: typeof sandboxedSetInterval;
+    lispifyFunction: typeof lispifyFunction;
+}
+export type SandboxFunction = (code: string, ...args: string[]) => () => unknown;
+export type SandboxEval = (code: string) => unknown;
+export type SandboxSetTimeout = (handler: TimerHandler, timeout?: number, ...args: unknown[]) => any;
+export type SandboxSetInterval = (handler: TimerHandler, timeout?: number, ...args: unknown[]) => any;
+export declare function createEvalContext(): IEvalContext;
+export declare function sandboxFunction(context: IExecContext, ticks?: Ticks): SandboxFunction;
+export declare function sandboxedEval(func: SandboxFunction): SandboxEval;
+export declare function sandboxedSetTimeout(func: SandboxFunction): SandboxSetTimeout;
+export declare function sandboxedSetInterval(func: SandboxFunction): SandboxSetInterval;

package/build/eval.js

@@ -0,0 +1,43 @@
+import { createFunction, currentTicks } from './executor.js';
+import parse, { lispifyFunction } from './parser.js';
+export function createEvalContext() {
+    return {
+        sandboxFunction,
+        sandboxedEval,
+        sandboxedSetTimeout,
+        sandboxedSetInterval,
+        lispifyFunction,
+    };
+}
+export function sandboxFunction(context, ticks) {
+    return SandboxFunction;
+    function SandboxFunction(...params) {
+        const code = params.pop() || '';
+        const parsed = parse(code);
+        return createFunction(params, parsed.tree, ticks || currentTicks.current, {
+            ...context,
+            constants: parsed.constants,
+            tree: parsed.tree,
+        }, undefined, 'anonymous');
+    }
+}
+export function sandboxedEval(func) {
+    return sandboxEval;
+    function sandboxEval(code) {
+        return func(code)();
+    }
+}
+export function sandboxedSetTimeout(func) {
+    return function sandboxSetTimeout(handler, ...args) {
+        if (typeof handler !== 'string')
+            return setTimeout(handler, ...args);
+        return setTimeout(func(handler), ...args);
+    };
+}
+export function sandboxedSetInterval(func) {
+    return function sandboxSetInterval(handler, ...args) {
+        if (typeof handler !== 'string')
+            return setInterval(handler, ...args);
+        return setInterval(func(handler), ...args);
+    };
+}