@cuxt/sandboxjs 0.1.0 → 0.1.3

package/dist/node/SandboxExec.js

@@ -1,225 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var executor = require('./executor.js');
-var utils = require('./utils.js');
-
-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;
-    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);
-        },
-    };
-}
-class SandboxExec {
-    constructor(options, evalContext) {
-        this.evalContext = evalContext;
-        this.setSubscriptions = new WeakMap();
-        this.changeSubscriptions = new WeakMap();
-        this.sandboxFunctions = new WeakMap();
-        this.haltSubscriptions = new Set();
-        this.resumeSubscriptions = new Set();
-        this.halted = false;
-        this.timeoutHandleCounter = 0;
-        this.setTimeoutHandles = new Map();
-        this.setIntervalHandles = new Map();
-        const opt = Object.assign({
-            audit: false,
-            forbidFunctionCalls: false,
-            forbidFunctionCreation: false,
-            globals: SandboxExec.SAFE_GLOBALS,
-            prototypeWhitelist: SandboxExec.SAFE_PROTOTYPES,
-            prototypeReplacements: new Map(),
-        }, options || {});
-        this.context = utils.createContext(this, opt);
-    }
-    static get SAFE_GLOBALS() {
-        return {
-            globalThis,
-            Function,
-            eval,
-            console: {
-                debug: console.debug,
-                error: console.error,
-                info: console.info,
-                log: console.log,
-                table: console.table,
-                warn: console.warn,
-            },
-            isFinite,
-            isNaN,
-            parseFloat,
-            parseInt,
-            decodeURI,
-            decodeURIComponent,
-            encodeURI,
-            encodeURIComponent,
-            escape,
-            unescape,
-            Boolean,
-            Number,
-            BigInt,
-            String,
-            Object,
-            Array,
-            Symbol,
-            Error,
-            EvalError,
-            RangeError,
-            ReferenceError,
-            SyntaxError,
-            TypeError,
-            URIError,
-            Int8Array,
-            Uint8Array,
-            Uint8ClampedArray,
-            Int16Array,
-            Uint16Array,
-            Int32Array,
-            Uint32Array,
-            Float32Array,
-            Float64Array,
-            Map,
-            Set,
-            WeakMap,
-            WeakSet,
-            Promise,
-            Intl,
-            JSON,
-            Math,
-            Date,
-            RegExp,
-        };
-    }
-    static get SAFE_PROTOTYPES() {
-        const protos = [
-            utils.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,
-            // Fetch API
-            Response,
-            Request,
-            Headers,
-            FormData,
-        ];
-        const map = new Map();
-        protos.forEach((proto) => {
-            map.set(proto, new Set());
-        });
-        map.set(Object, new Set([
-            'constructor',
-            'name',
-            'entries',
-            'fromEntries',
-            'getOwnPropertyNames',
-            'is',
-            'keys',
-            'hasOwnProperty',
-            'isPrototypeOf',
-            'propertyIsEnumerable',
-            'toLocaleString',
-            'toString',
-            'valueOf',
-            'values',
-        ]));
-        return map;
-    }
-    subscribeGet(callback, context) {
-        context.getSubscriptions.add(callback);
-        return { unsubscribe: () => context.getSubscriptions.delete(callback) };
-    }
-    subscribeSet(obj, name, callback, context) {
-        return subscribeSet(obj, name, callback, context);
-    }
-    subscribeSetGlobal(obj, name, callback) {
-        return subscribeSet(obj, name, callback, this);
-    }
-    subscribeHalt(cb) {
-        this.haltSubscriptions.add(cb);
-        return {
-            unsubscribe: () => {
-                this.haltSubscriptions.delete(cb);
-            },
-        };
-    }
-    subscribeResume(cb) {
-        this.resumeSubscriptions.add(cb);
-        return {
-            unsubscribe: () => {
-                this.resumeSubscriptions.delete(cb);
-            },
-        };
-    }
-    haltExecution(haltContext) {
-        if (this.halted)
-            return;
-        this.halted = true;
-        for (const cb of this.haltSubscriptions) {
-            cb(haltContext);
-        }
-    }
-    resumeExecution() {
-        if (!this.halted)
-            return;
-        if (this.context.ticks.tickLimit && this.context.ticks.ticks >= this.context.ticks.tickLimit) {
-            throw new utils.SandboxExecutionQuotaExceededError('Cannot resume execution: tick limit exceeded');
-        }
-        this.halted = false;
-        for (const cb of this.resumeSubscriptions) {
-            cb();
-        }
-    }
-    getContext(fn) {
-        return this.sandboxFunctions.get(fn);
-    }
-    executeTree(context, scopes = []) {
-        return executor.executeTree(context.ctx.ticks, context, context.tree, scopes);
-    }
-    executeTreeAsync(context, scopes = []) {
-        return executor.executeTreeAsync(context.ctx.ticks, context, context.tree, scopes);
-    }
-}
-
-exports.LocalScope = utils.LocalScope;
-exports.SandboxAccessError = utils.SandboxAccessError;
-exports.SandboxCapabilityError = utils.SandboxCapabilityError;
-exports.SandboxError = utils.SandboxError;
-exports.SandboxExecutionTreeError = utils.SandboxExecutionTreeError;
-exports.default = SandboxExec;

package/dist/node/eval.d.ts

@@ -1,27 +0,0 @@
-import { lispifyFunction } from './parser.js';
-import { IExecContext } from './utils.js';
-export interface IEvalContext {
-    sandboxFunction: typeof sandboxFunction;
-    sandboxAsyncFunction: typeof sandboxAsyncFunction;
-    sandboxedEval: (func: SandboxFunction, context: IExecContext) => SandboxEval;
-    sandboxedSetTimeout: typeof sandboxedSetTimeout;
-    sandboxedSetInterval: typeof sandboxedSetInterval;
-    sandboxedClearTimeout: typeof sandboxedClearTimeout;
-    sandboxedClearInterval: typeof sandboxedClearInterval;
-    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 type SandboxClearTimeout = (handle: number) => void;
-export type SandboxClearInterval = (handle: number) => void;
-export declare function createEvalContext(): IEvalContext;
-export declare function sandboxFunction(context: IExecContext): SandboxFunction;
-export type SandboxAsyncFunction = (code: string, ...args: string[]) => () => Promise<unknown>;
-export declare function sandboxAsyncFunction(context: IExecContext): SandboxAsyncFunction;
-export declare function sandboxedEval(func: SandboxFunction, context: IExecContext): SandboxEval;
-export declare function sandboxedSetTimeout(func: SandboxFunction, context: IExecContext): SandboxSetTimeout;
-export declare function sandboxedClearTimeout(context: IExecContext): SandboxClearTimeout;
-export declare function sandboxedClearInterval(context: IExecContext): SandboxClearInterval;
-export declare function sandboxedSetInterval(func: SandboxFunction, context: IExecContext): SandboxSetInterval;

package/dist/node/executor.d.ts

@@ -1,124 +0,0 @@
-import { LispItem, Lisp } from './parser.js';
-import { IAuditReport, IExecContext, IScope, LispType, Prop, Scope, Ticks } from './utils.js';
-export type Done<T = any> = (err?: any, res?: T | typeof optional) => void;
-export declare class ExecReturn<T> {
-    auditReport: IAuditReport | undefined;
-    result: T;
-    returned: boolean;
-    breakLoop: boolean;
-    continueLoop: boolean;
-    constructor(auditReport: IAuditReport | undefined, result: T, returned: boolean, breakLoop?: boolean, continueLoop?: boolean);
-}
-export type Unknown = undefined | null | Record<string | number, unknown>;
-export interface IChange {
-    type: string;
-}
-export interface ICreate extends IChange {
-    type: 'create';
-    prop: number | string;
-}
-export interface IReplace extends IChange {
-    type: 'replace';
-}
-export interface IDelete extends IChange {
-    type: 'delete';
-    prop: number | string;
-}
-export interface IReverse extends IChange {
-    type: 'reverse';
-}
-export interface ISort extends IChange {
-    type: 'sort';
-}
-export interface IPush extends IChange {
-    type: 'push';
-    added: unknown[];
-}
-export interface IPop extends IChange {
-    type: 'pop';
-    removed: unknown[];
-}
-export interface IShift extends IChange {
-    type: 'shift';
-    removed: unknown[];
-}
-export interface IUnShift extends IChange {
-    type: 'unshift';
-    added: unknown[];
-}
-export interface ISplice extends IChange {
-    type: 'splice';
-    startIndex: number;
-    deleteCount: number;
-    added: unknown[];
-    removed: unknown[];
-}
-export interface ICopyWithin extends IChange {
-    type: 'copyWithin';
-    startIndex: number;
-    endIndex: number;
-    added: unknown[];
-    removed: unknown[];
-}
-export type Change = ICreate | IReplace | IDelete | IReverse | ISort | IPush | IPop | IUnShift | IShift | ISplice | ICopyWithin;
-declare const optional: {};
-export declare function createFunction(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): (...args: unknown[]) => unknown;
-export declare function createFunctionAsync(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): (...args: unknown[]) => Promise<unknown>;
-export declare function assignCheck(obj: Prop, context: IExecContext, op?: string): void;
-export declare class KeyVal {
-    key: string | SpreadObject;
-    val: unknown;
-    constructor(key: string | SpreadObject, val: unknown);
-}
-export declare class SpreadObject {
-    item: {
-        [key: string]: unknown;
-    };
-    constructor(item: {
-        [key: string]: unknown;
-    });
-}
-export declare class SpreadArray {
-    item: unknown[];
-    constructor(item: unknown[]);
-}
-export declare class If {
-    t: Lisp;
-    f: Lisp;
-    constructor(t: Lisp, f: Lisp);
-}
-type OpCallback<a, b, obj, bobj> = (params: OpsCallbackParams<a, b, obj, bobj>) => void;
-export declare const ops: Map<LispType, OpCallback<any, any, any, any>>;
-export declare function addOps<a = unknown, b = unknown, obj = unknown, bobj = unknown>(type: LispType, cb: OpCallback<a, b, obj, bobj>): void;
-export declare function execMany(ticks: Ticks, exec: Execution, tree: Lisp[], done: Done, scope: Scope, context: IExecContext, inLoopOrSwitch?: string): void;
-type Execution = <T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done<T>, inLoopOrSwitch?: string) => void;
-export interface AsyncDoneRet {
-    isInstant: boolean;
-    instant: any;
-    p: Promise<{
-        result: any;
-    }>;
-}
-export declare function asyncDone(callback: (done: Done) => void): AsyncDoneRet;
-export declare function syncDone(callback: (done: Done) => void): {
-    result: any;
-};
-export declare function execAsync<T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, doneOriginal: Done<T>, inLoopOrSwitch?: string): Promise<void>;
-export declare function execSync<T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done<T>, inLoopOrSwitch?: string): void;
-type OpsCallbackParams<a, b, obj, bobj> = {
-    op: LispType;
-    exec: Execution;
-    a: a;
-    b: b;
-    obj: obj;
-    bobj: bobj;
-    ticks: Ticks;
-    tree: LispItem;
-    scope: Scope;
-    context: IExecContext;
-    done: Done;
-    inLoopOrSwitch?: string;
-};
-export declare function executeTree<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes?: IScope[], inLoopOrSwitch?: string): ExecReturn<T>;
-export declare function executeTreeAsync<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes?: IScope[], inLoopOrSwitch?: string): Promise<ExecReturn<T>>;
-export {};