Sablejs

<a href="https://www.npmjs.com/package/sablejs"><img src="https://img.shields.io/npm/v/sablejs.svg?sanitize=true" alt="Version"></a>

🎉 sablejs 2.0 will be opening all the code, please click to learn more about our milestone and goals.

English | 简体中文

The safer and faster ECMA5.1 interpreter written by JavaScript, it can be used:

1. Sandbox (like Figma Plugin Sandbox, but better and easier to use);
2. Protect JavaScript source code via AOT compiling to opcode.

sablejs covered ~95% test262 es5-tests cases, it can be safely used in production.

• Quick Start
• APIs
• Benchmark
• Limits
• Bindings
• License

Quick Start

sablejs includes the Compiler and Interpreter independently, so we removed the related dynamic api from the spec (see Limits 1). In short, you need to compile your JavaScript code with sablejs cli before you run it.

Example

Suppose we have the following code in fib.js:

function fib(n) {
  return n < 2 ? n : fib(n - 1) + fib(n - 2);
}

var start = Date.now();
console.log("[INFO] fib: " + fib(30));
console.log("[INFO] time consuming: " + (Date.now() - start) + "ms");

Compile It!

> npm i sablejs -g
> sablejs -i fib.js -o output # get output file that contains base64 string

sablejs cli includes the following commands:

Usage: sablejs [options]

Options:
  -v, --vers           output the current version
  -i, --input <path>   compile input filepath
  -o, --output <path>  compile output filepath
  -j  --json           don't do Base64 compress, output simple json result
  -s, --slient         don't output log
  -h, --help

Run It!

> npm install sablejs --save

or you can import to your html directly

<script src="https://cdn.jsdelivr.net/npm/sablejs@1.0.8/runtime.js"></script>

Browser

const VM = require("sablejs/runtime")();

// import console.log function to vm call
const vm = new VM();
const vGlobal = vm.getGlobal();
const vConsole = vm.createObject();
const vLog = vm.createFunction("log", function () {
  const temp = [];
  for (let i = 0; i < arguments.length; i++) {
    temp.push(vm.asString(arguments[i]));
  }

  console.log(...temp);
  return vm.createUndefined();
});

vm.setProperty(vConsole, "log", vLog);
vm.setProperty(vGlobal, "console", vConsole);

(async () => {
  const resp = await fetch("<output url>");
  const data = await resp.text();
  vm.run(data);
  vm.destroy();
})();

Node

const VM = require("sablejs/runtime")();
const fs = require("fs");

// import console.log function to vm call
const vm = new VM();
const vGlobal = vm.getGlobal();
const vConsole = vm.createObject();
const vLog = vm.createFunction("log", function () {
  const temp = [];
  for (let i = 0; i < arguments.length; i++) {
    temp.push(vm.asString(arguments[i]));
  }

  console.log(...temp);
  return vm.createUndefined();
});

vm.setProperty(vConsole, "log", vLog);
vm.setProperty(vGlobal, "console", vConsole);

// please run: sablejs -i fib.js -o output
vm.run(fs.readFileSync("./output").toString());
vm.destroy();

APIs

• VM.prototype.run(source, isSimpleJSON)
  • source: String - the compiled result via sablejs compiler
  • isSimpleJSON: Boolean - if be true, you should use -j to make compiler output simple json result, default false.
  • return: undefined

Initialize the VM and execute the compiled source code.

const VM = require('sablejs/runtime')();
const vm = new VM();

// source should be base64 string via sablejs compiling
vm.run(`<compiled source string>`);

• VM.prototype.getGlobal()
  • return: Value

Returns the global in the VM, which is similar to the window in browser and the global in Node.js.

const global = vm.getGlobal();

• VM.prototype.createUndefined()
  • return Value

Create an undefined boxed type.

const vUndefined = vm.createUndefined();

• VM.prototype.createNull()
  • return: Value

Create an null boxed type.

const vNull = vm.createNull();

• VM.prototype.createBoolean(bool)
  • bool: Boolean
  • return Value

Create an bool boxed type.

const vBoolean = vm.createBoolean(true);

• VM.prototype.createNumber(num)
  • num: Number
  • return Value

Create an number boxed type.

const vNumber = vm.createNumber(1024);

• VM.prototype.createString(str)
  • str: String
  • return Value

Create an string boxed type.

const vString = vm.createString('Hello World!');

• VM.prototype.createObject()
  • return Value

Create an object boxed type.

const vObject = vm.createObject();

• VM.prototype.createArray(length)
  • length: Number | undefined
  • return Value

Create an array boxed type.

const vArray1 = vm.createArray();
// or
const vArray2 = vm.createArray(128);

• VM.prototype.createFunction(name, func)
  • name: String
  • func: Function
  • return Value

Create an funcntion boxed type. It receives a function name and the specific implementation of the function. Both the function parameter and this are boxed types in func.

const vFunction = vm.createFunction("trim", function(str) {
  // this is the undefined or new's instannce boxed type
  // str maybe the string boxed type, we need to check it
});

• VM.prototype.createError(message)
  • message: String | undefined
  • return Value

Create an error boxed type.

const vError1 = vm.createError();
// or
const vError2 = vm.createError("unknown error");

• VM.prototype.createRegExp(pattern, flags)
  • pattern: String
  • flags: String | undefined
  • return Value

Create an regexp boxed type.

const vRegExp = vm.createRegExp("\\w+", "ig");

• VM.prototype.createDate()
  • return Value

Create an date boxed type.

const vDate = vm.createDate();

• VM.prototype.isUndefined(value)
  • value: Value
  • return Boolean

Used to determine if the type is undefinend.

const vUndefined = vm.createUndefined();
if(vm.isUndefined(vUndefined)) {
  // ...
}

• VM.prototype.isNull(value)
  • value: Value
  • return Boolean

Used to determine if the type is null.

const vNull = vm.createNull();
if(vm.isNull(vNull)) {
  // ...
}

• VM.prototype.isBoolean(value)
  • value: Value
  • return Boolean

Used to determine if the type is bool.

const vBoolean = vm.createBoolean(true);
if(vm.isBoolean(vBoolean)) {
  // ...
}

• VM.prototype.isNumber(value)
  • value: Value
  • return Boolean

Used to determine if the type is number.

const vNumber = vm.createNumber(1024);
if(vm.isNumber(vNumber)) {
  // ...
}

• VM.prototype.isString(value)
  • value: Value
  • return Boolean

Used to determine if the type is string.

const vString = vm.createString("Hello World!");
if(vm.isString(vString)) {
  // ...
}

• VM.prototype.isObject(value)
  • value: Value
  • return Boolean

Used to determine if the type is object.

const vObject = vm.createObject();
const vArray = vm.createArray();
if(vm.isObject(vObject) && vm.isObject(vArray)) {
  // ...
}

• VM.prototype.isArray(value)
  • value: Value
  • return Boolean

Used to determine if the type is array.

const vArray = vm.createArray();
if(vm.isArray(vArray)) {
  // ...
}

• VM.prototype.isFunction(value)
  • value: Value
  • return Boolean

Used to determine if the type is function.

const vFunction = vm.createFunction("log", function(){});
if(vm.isFunction(vFunction)){
  // ...
}

• VM.prototype.isError(value)
  • value: Value
  • return Boolean

Used to determine if the type is error.

const vError = vm.createError('unknown error');
if(vm.isError(vError)){
  // ...
}

• VM.prototype.isRegExp(value)
  • value: Value
  • return Boolean

Used to determine if the type is regexp.

const vRegExp = vm.createRegExp("\\w+", "ig");
if(vm.isRegExp(vRegExp)){
  // ...
}

• VM.prototype.isDate(value)
  • value: Value
  • return Boolean

Used to determine if the type is date.

const vDate = vm.createDate();
if(vm.isDate(vDate)){
  // ...
}

• VM.prototype.asUndefined(value)
  • value: Value
  • return undefined

Converting undefined boxed type to plain undefined value.

const vUndefined = vm.createUndefined();
vm.asUndefined(vUndefined) === undefined;

• VM.prototype.asNull(value)
  • value: Value
  • return null

Converting null boxed type to plain null value.

const vNull = vm.createNull();
vm.asNull(vNull) === null;

• VM.prototype.asBoolean(value)
  • value: Value
  • return Boolean

Converting bool boxed type to plain bool value.

const vBoolean = vm.createBoolean(true);
const boolean = vm.asBoolean(vBoolean);
if(boolean === true) {
  // ...
}

• VM.prototype.asNumber(value)
  • value: Value
  • return Number

Converting number boxed type to plain number value.

const vNumber = vm.createNumber(1024);
const number = vm.asNumber(vNumber);
if(number === 102