greybel-interpreter 3.5.1 → 4.0.1

package/dist/vm.js

@@ -0,0 +1,662 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VM = exports.VMState = exports.Debugger = void 0;
+const context_1 = require("./context");
+const instruction_1 = require("./byte-compiler/instruction");
+const default_1 = require("./types/default");
+const stack_1 = require("./utils/stack");
+const nil_1 = require("./types/nil");
+const error_1 = require("./utils/error");
+const with_intrinsics_1 = require("./types/with-intrinsics");
+const boolean_1 = require("./types/boolean");
+const function_1 = require("./types/function");
+const evaluation_1 = require("./vm/evaluation");
+const number_1 = require("./types/number");
+const map_1 = require("./types/map");
+const list_1 = require("./types/list");
+const next_tick_1 = require("./utils/next-tick");
+const string_1 = require("./types/string");
+const events_1 = __importDefault(require("events"));
+const object_value_1 = require("./utils/object-value");
+class Debugger {
+    constructor() {
+        this.breakpoint = false;
+        this.nextStep = false;
+    }
+    debug(...segments) {
+        console.debug(...segments);
+        return default_1.DefaultType.Void;
+    }
+    setBreakpoint(breakpoint) {
+        this.breakpoint = breakpoint;
+        return this;
+    }
+    getBreakpoint(vm) {
+        return this.breakpoint;
+    }
+    next() {
+        this.nextStep = true;
+        return this;
+    }
+    resume() {
+        if (!this.breakpoint) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            const check = () => {
+                if (!this.breakpoint) {
+                    resolve();
+                }
+                else if (this.nextStep) {
+                    this.nextStep = false;
+                    resolve();
+                }
+                else {
+                    setImmediate(check);
+                }
+            };
+            check();
+        });
+    }
+    interact(vm, _source) {
+        const me = this;
+        console.warn('Debugger is not setup.');
+        console.info(vm);
+        me.breakpoint = false;
+    }
+}
+exports.Debugger = Debugger;
+var VMState;
+(function (VMState) {
+    VMState[VMState["PREPARATION"] = 0] = "PREPARATION";
+    VMState[VMState["PENDING"] = 1] = "PENDING";
+    VMState[VMState["FINISHED"] = 2] = "FINISHED";
+})(VMState = exports.VMState || (exports.VMState = {}));
+class VM {
+    constructor(options) {
+        var _a, _b;
+        this.ACTIONS_PER_LOOP = 120;
+        this.STACK_LIMIT = 512;
+        this.stack = new Array(this.STACK_LIMIT);
+        this.signal = new events_1.default();
+        this.state = VMState.PREPARATION;
+        this.actionCount = 0;
+        this.sp = 0;
+        this.time = -1;
+        this.target = options.target;
+        this.frames = new stack_1.Stack(options.globals);
+        this.contextTypeIntrinsics = options.contextTypeIntrinsics;
+        this.handler = options.handler;
+        this.debugger = options.debugger;
+        this.environmentVariables = (_a = options.environmentVariables) !== null && _a !== void 0 ? _a : new Map();
+        this.iterators = new stack_1.Stack();
+        this.imports = (_b = options.imports) !== null && _b !== void 0 ? _b : new Map();
+    }
+    getTime() {
+        return this.time;
+    }
+    isPending() {
+        return this.state === VMState.PENDING;
+    }
+    getStacktrace() {
+        const frames = this.frames.values();
+        const stacktrace = [];
+        for (let index = frames.length - 1; index >= 0; index--) {
+            stacktrace.push(frames[index].getCurrentInstruction());
+        }
+        return stacktrace;
+    }
+    getOpenHandles() {
+        return this.sp;
+    }
+    exit() {
+        this.signal.emit('exit');
+    }
+    getFrame() {
+        return this.frames.peek();
+    }
+    pushStack(value) {
+        this.stack[this.sp++] = value;
+    }
+    popStack() {
+        return this.stack[--this.sp];
+    }
+    createFrame(options) {
+        const ctx = this.getFrame().fork({
+            code: options.code,
+            type: context_1.ContextType.Function,
+            self: options.self,
+            super: options.super,
+            outer: options.outer
+        });
+        this.frames.push(ctx);
+        return ctx;
+    }
+    popFrame() {
+        return this.frames.pop();
+    }
+    exec() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function* () {
+            let shouldContinue = true;
+            const exitCallback = () => {
+                shouldContinue = false;
+            };
+            this.time = Date.now();
+            this.state = VMState.PENDING;
+            this.signal.once('exit', exitCallback);
+            while (shouldContinue) {
+                const frame = this.getFrame();
+                if (frame.code.length === frame.ip) {
+                    this.popFrame();
+                    continue;
+                }
+                const instruction = frame.code[frame.ip++];
+                switch (instruction.op) {
+                    case instruction_1.OpCode.NOOP: {
+                        continue;
+                    }
+                    case instruction_1.OpCode.PUSH: {
+                        const pushInstruction = instruction;
+                        this.pushStack(pushInstruction.value);
+                        break;
+                    }
+                    case instruction_1.OpCode.POP: {
+                        this.popStack();
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_GLOBALS: {
+                        this.pushStack(frame.globals.scope);
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_OUTER: {
+                        this.pushStack(((_a = frame.outer) !== null && _a !== void 0 ? _a : frame.globals).scope);
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_LOCALS: {
+                        this.pushStack(frame.locals.scope);
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_SELF: {
+                        this.pushStack((_b = frame.self) !== null && _b !== void 0 ? _b : default_1.DefaultType.Void);
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_SUPER: {
+                        this.pushStack((_c = frame.super) !== null && _c !== void 0 ? _c : default_1.DefaultType.Void);
+                        break;
+                    }
+                    case instruction_1.OpCode.IMPORT: {
+                        const importInstruction = instruction;
+                        const code = this.imports.get(importInstruction.path);
+                        this.createFrame({ code });
+                        break;
+                    }
+                    case instruction_1.OpCode.ASSIGN: {
+                        const value = this.popStack();
+                        const key = this.popStack();
+                        const base = this.popStack();
+                        if (!(base instanceof with_intrinsics_1.CustomValueWithIntrinsics)) {
+                            throw new error_1.RuntimeError(`Base left side must be a value with intrinsics!`, this);
+                        }
+                        else if (key instanceof nil_1.CustomNil) {
+                            throw new error_1.RuntimeError(`Key left side cannot be null!`, this);
+                        }
+                        base.set(key, value);
+                        break;
+                    }
+                    case instruction_1.OpCode.FUNCTION_DEFINITION: {
+                        const functionInstruction = instruction;
+                        const fn = new function_1.CustomFunction('anonymous', functionInstruction.code, functionInstruction.arguments, functionInstruction.ignoreOuter ? frame.globals : frame);
+                        this.pushStack(fn);
+                        break;
+                    }
+                    case instruction_1.OpCode.CALL: {
+                        const callInstruction = instruction;
+                        const args = new Array(callInstruction.length);
+                        for (let i = 0; i < callInstruction.length; i++) {
+                            args[i] = this.popStack();
+                        }
+                        const fn = this.popStack();
+                        if (fn instanceof function_1.CustomFunction) {
+                            if (callInstruction.length > fn.arguments.length) {
+                                throw new Error('Too many arguments.');
+                            }
+                            const newFrame = this.createFrame({ code: fn.value, outer: fn.outer });
+                            const argsCount = args.length;
+                            for (let index = 0; index < argsCount; index++) {
+                                const argument = args.shift();
+                                const paramNum = argsCount - 1 - index;
+                                if (paramNum >= fn.arguments.length) {
+                                    throw new Error('Too many arguments.');
+                                }
+                                const param = fn.arguments[paramNum].name;
+                                if (param.toString() == "self") {
+                                    newFrame.self = argument;
+                                    newFrame.super = argument instanceof map_1.CustomMap ? ((_d = argument.getIsa()) !== null && _d !== void 0 ? _d : new map_1.CustomMap()) : null;
+                                }
+                                else {
+                                    newFrame.set(param, argument);
+                                }
+                            }
+                            for (let paramNum = argsCount; paramNum < fn.arguments.length; paramNum++) {
+                                newFrame.set(fn.arguments[paramNum].name, fn.arguments[paramNum].defaultValue);
+                            }
+                            newFrame.injectContext();
+                        }
+                        break;
+                    }
+                    case instruction_1.OpCode.CALL_WITH_CONTEXT: {
+                        const callInstruction = instruction;
+                        const args = new Array(callInstruction.length);
+                        for (let i = 0; i < callInstruction.length; i++) {
+                            args[i] = this.popStack();
+                        }
+                        const propertyName = this.popStack();
+                        const context = this.popStack();
+                        const fn = context.get(propertyName, this.contextTypeIntrinsics);
+                        if (fn instanceof function_1.CustomFunction) {
+                            const newFrame = this.createFrame({
+                                code: fn.value,
+                                self: context,
+                                super: context instanceof map_1.CustomMap ? ((_e = context.getIsa()) !== null && _e !== void 0 ? _e : new map_1.CustomMap()) : null,
+                                outer: fn.outer
+                            });
+                            const argsCount = args.length;
+                            let selfParam = fn.arguments.length > 0 && fn.arguments[0].name.toString() == "self" ? 1 : 0;
+                            for (let index = 0; index < argsCount; index++) {
+                                const argument = args.shift();
+                                const paramNum = argsCount - 1 - index + selfParam;
+                                if (paramNum >= fn.arguments.length) {
+                                    throw new Error('Too many arguments.');
+                                }
+                                const param = fn.arguments[paramNum].name;
+                                if (param.toString() !== "self")
+                                    newFrame.set(param, argument);
+                            }
+                            for (let paramNum = argsCount + selfParam; paramNum < fn.arguments.length; paramNum++) {
+                                newFrame.set(fn.arguments[paramNum].name, fn.arguments[paramNum].defaultValue);
+                            }
+                            newFrame.injectContext();
+                        }
+                        break;
+                    }
+                    case instruction_1.OpCode.CALL_SUPER_PROPERTY: {
+                        const callInstruction = instruction;
+                        const args = new Array(callInstruction.length);
+                        for (let i = 0; i < callInstruction.length; i++) {
+                            args[i] = this.popStack();
+                        }
+                        const property = this.popStack();
+                        const context = frame.super;
+                        if (!(context instanceof with_intrinsics_1.CustomValueWithIntrinsics)) {
+                            throw new error_1.RuntimeError(`Unknown path ${property.toString()}.`, this);
+                        }
+                        const ret = context.getWithOrigin(property, this.contextTypeIntrinsics);
+                        const fn = ret.value;
+                        if (fn instanceof function_1.CustomFunction) {
+                            const newFrame = this.createFrame({
+                                code: fn.value,
+                                self: frame.self,
+                                super: ret.origin instanceof map_1.CustomMap ? ((_f = ret.origin.getIsa()) !== null && _f !== void 0 ? _f : new map_1.CustomMap()) : null,
+                                outer: fn.outer
+                            });
+                            let selfParam = fn.arguments.length > 0 && fn.arguments[0].name.toString() == "self" ? 1 : 0;
+                            const argsCount = args.length;
+                            for (let index = 0; index < argsCount; index++) {
+                                const argument = args.shift();
+                                const paramNum = argsCount - 1 - index + selfParam;
+                                if (paramNum >= fn.arguments.length) {
+                                    throw new Error('Too many arguments.');
+                                }
+                                const param = fn.arguments[paramNum].name;
+                                if (param.toString() !== "self")
+                                    newFrame.set(param, argument);
+                            }
+                            for (let paramNum = argsCount + selfParam; paramNum < fn.arguments.length; paramNum++) {
+                                newFrame.set(fn.arguments[paramNum].name, fn.arguments[paramNum].defaultValue);
+                            }
+                            newFrame.injectContext();
+                        }
+                        break;
+                    }
+                    case instruction_1.OpCode.CONSTRUCT_MAP: {
+                        const mapConstructInstruction = instruction;
+                        const map = [];
+                        for (let index = 0; index < mapConstructInstruction.length; index++) {
+                            const value = this.popStack();
+                            const key = this.popStack();
+                            map.unshift([key, value]);
+                        }
+                        this.pushStack(new map_1.CustomMap(new object_value_1.ObjectValue(map)));
+                        break;
+                    }
+                    case instruction_1.OpCode.CONSTRUCT_LIST: {
+                        const listConstructInstruction = instruction;
+                        const list = [];
+                        for (let index = 0; index < listConstructInstruction.length; index++) {
+                            const value = this.popStack();
+                            list.unshift(value);
+                        }
+                        this.pushStack(new list_1.CustomList(list));
+                        break;
+                    }
+                    case instruction_1.OpCode.GOTO_A_IF_FALSE: {
+                        const condition = this.popStack();
+                        if (condition.toTruthy()) {
+                            break;
+                        }
+                        const gotoAInstruction = instruction;
+                        frame.ip = gotoAInstruction.goto.ip;
+                        break;
+                    }
+                    case instruction_1.OpCode.GOTO_A: {
+                        const gotoAInstruction = instruction;
+                        frame.ip = gotoAInstruction.goto.ip;
+                        break;
+                    }
+                    case instruction_1.OpCode.GOTO_A_IF_FALSE: {
+                        const condition = this.popStack();
+                        if (condition.toTruthy()) {
+                            break;
+                        }
+                        const gotoAInstruction = instruction;
+                        frame.ip = gotoAInstruction.goto.ip;
+                        break;
+                    }
+                    case instruction_1.OpCode.PUSH_ITERATOR: {
+                        const value = this.popStack();
+                        const iterator = value[Symbol.iterator]();
+                        this.iterators.push(iterator);
+                        break;
+                    }
+                    case instruction_1.OpCode.POP_ITERATOR: {
+                        this.iterators.pop();
+                        break;
+                    }
+                    case instruction_1.OpCode.NEXT: {
+                        const nextInstruction = instruction;
+                        let idx = frame.get(nextInstruction.idxVariable, this.contextTypeIntrinsics).toNumber();
+                        const iterator = this.iterators.peek();
+                        iterator.index = ++idx;
+                        const iteratorResult = iterator.next();
+                        this.pushStack(new boolean_1.CustomBoolean(!iteratorResult.done));
+                        if (!iteratorResult.done) {
+                            frame.set(nextInstruction.variable, iteratorResult.value);
+                            frame.set(nextInstruction.idxVariable, new number_1.CustomNumber(idx));
+                        }
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_VARIABLE: {
+                        const getVariableInstroduction = instruction;
+                        const ret = frame.locals.get(getVariableInstroduction.property, this.contextTypeIntrinsics);
+                        if (ret instanceof function_1.CustomFunction && getVariableInstroduction.invoke) {
+                            const newFrame = this.createFrame({
+                                code: ret.value,
+                                outer: ret.outer
+                            });
+                            for (let paramNum = 0; paramNum < ret.arguments.length; paramNum++) {
+                                newFrame.set(ret.arguments[paramNum].name, ret.arguments[paramNum].defaultValue);
+                            }
+                            newFrame.injectContext();
+                            break;
+                        }
+                        this.pushStack(ret);
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_PROPERTY: {
+                        const getPropertyInstruction = instruction;
+                        const property = this.popStack();
+                        const context = this.popStack();
+                        if (!(context instanceof with_intrinsics_1.CustomValueWithIntrinsics)) {
+                            throw new error_1.RuntimeError(`Unknown path ${property.toString()}.`, this);
+                        }
+                        const ret = context.getWithOrigin(property, this.contextTypeIntrinsics);
+                        if (ret.value instanceof function_1.CustomFunction && getPropertyInstruction.invoke) {
+                            const newFrame = this.createFrame({
+                                code: ret.value.value,
+                                self: context,
+                                super: ret.origin instanceof map_1.CustomMap ? ((_g = ret.origin.getIsa()) !== null && _g !== void 0 ? _g : new map_1.CustomMap()) : null,
+                                outer: ret.value.outer
+                            });
+                            for (let paramNum = 0; paramNum < ret.value.arguments.length; paramNum++) {
+                                newFrame.set(ret.value.arguments[paramNum].name, ret.value.arguments[paramNum].defaultValue);
+                            }
+                            newFrame.injectContext();
+                            break;
+                        }
+                        this.pushStack(ret.value);
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_SUPER_PROPERTY: {
+                        const getPropertyInstruction = instruction;
+                        const property = this.popStack();
+                        const ret = frame.super.getWithOrigin(property, this.contextTypeIntrinsics);
+                        if (ret.value instanceof function_1.CustomFunction && getPropertyInstruction.invoke) {
+                            const newFrame = this.createFrame({
+                                code: ret.value.value,
+                                self: frame.self,
+                                super: ret.origin instanceof map_1.CustomMap ? ((_h = ret.origin.getIsa()) !== null && _h !== void 0 ? _h : new map_1.CustomMap()) : null,
+                                outer: ret.value.outer
+                            });
+                            for (let paramNum = 0; paramNum < ret.value.arguments.length; paramNum++) {
+                                newFrame.set(ret.value.arguments[paramNum].name, ret.value.arguments[paramNum].defaultValue);
+                            }
+                            newFrame.injectContext();
+                            break;
+                        }
+                        this.pushStack(ret.value);
+                        break;
+                    }
+                    case instruction_1.OpCode.CALL_INTERNAL: {
+                        const callInstruction = instruction;
+                        const args = new Map();
+                        const callback = callInstruction.callback;
+                        for (const arg of callInstruction.arguments) {
+                            const value = frame.scope.value.get(arg.name);
+                            args.set(arg.name.toString(), value);
+                        }
+                        this.pushStack(yield callback(this, frame.self, args));
+                        break;
+                    }
+                    case instruction_1.OpCode.SLICE: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        const value = this.popStack();
+                        if (value instanceof list_1.CustomList || value instanceof string_1.CustomString) {
+                            this.pushStack(value.slice(a, b));
+                        }
+                        else {
+                            this.pushStack(default_1.DefaultType.Void);
+                        }
+                        break;
+                    }
+                    case instruction_1.OpCode.NEW: {
+                        const value = this.popStack();
+                        if (value instanceof map_1.CustomMap) {
+                            this.pushStack(value.createInstance());
+                        }
+                        else {
+                            this.pushStack(value);
+                        }
+                        break;
+                    }
+                    case instruction_1.OpCode.NEGATE: {
+                        const value = this.popStack();
+                        this.pushStack(new number_1.CustomNumber(-value.toNumber()));
+                        break;
+                    }
+                    case instruction_1.OpCode.FALSIFY: {
+                        const value = this.popStack();
+                        this.pushStack(new boolean_1.CustomBoolean(!value.toTruthy()));
+                        break;
+                    }
+                    case instruction_1.OpCode.ISA: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack(new boolean_1.CustomBoolean(a.instanceOf(b, this.contextTypeIntrinsics)));
+                        break;
+                    }
+                    case instruction_1.OpCode.BITWISE_AND: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalBitwiseAnd)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.BITWISE_OR: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalBitwiseOr)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.BITWISE_LEFT_SHIFT: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalBitwiseLeftShift)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.BITWISE_RIGHT_SHIFT: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalBitwiseRightShift)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.BITWISE_UNSIGNED_RIGHT_SHIFT: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalBitwiseUnsignedRightShift)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.ADD: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalAdd)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.SUB: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalSub)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.MUL: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalMul)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.DIV: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalDiv)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.MOD: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalMod)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.POW: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalPow)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.EQUAL: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalEqual)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.NOT_EQUAL: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalNotEqual)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.GREATER_THAN: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalGreaterThan)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.GREATER_THAN_OR_EQUAL: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalGreaterThanOrEqual)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.LESS_THAN: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalLessThan)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.LESS_THAN_OR_EQUAL: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalLessThanOrEqual)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.AND: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalAnd)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.OR: {
+                        const b = this.popStack();
+                        const a = this.popStack();
+                        this.pushStack((0, evaluation_1.evalOr)(a, b));
+                        break;
+                    }
+                    case instruction_1.OpCode.RETURN: {
+                        const value = this.popStack();
+                        this.popFrame();
+                        this.pushStack(value);
+                        break;
+                    }
+                    case instruction_1.OpCode.GET_ENVAR: {
+                        const key = this.popStack();
+                        const value = this.environmentVariables.get(key.toString());
+                        this.pushStack(new string_1.CustomString(value));
+                        break;
+                    }
+                    case instruction_1.OpCode.BREAKPOINT: {
+                        if (this.debugger.getBreakpoint(this)) {
+                            this.debugger.interact(this, instruction.source);
+                            yield this.debugger.resume();
+                        }
+                        break;
+                    }
+                    case instruction_1.OpCode.BREAKPOINT_ENABLE: {
+                        this.debugger.setBreakpoint(true);
+                        break;
+                    }
+                    case instruction_1.OpCode.HALT: {
+                        this.state = VMState.FINISHED;
+                        this.signal.off('exit', exitCallback);
+                        return;
+                    }
+                }
+                if (this.actionCount++ === this.ACTIONS_PER_LOOP) {
+                    this.actionCount = 0;
+                    yield (0, next_tick_1.nextTick)();
+                }
+            }
+        });
+    }
+}
+exports.VM = VM;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greybel-interpreter",
-    "version": "3.5.1",
+    "version": "4.0.1",
     "description": "Interpreter",
     "main": "dist/index",
     "typings": "dist/index",

package/dist/cps.d.ts

@@ -1,16 +0,0 @@
-import { ASTBase } from 'miniscript-core';
-import { HandlerContainer } from './handler-container';
-import { Operation } from './operations/operation';
-export declare class CPSContext {
-    readonly target: string;
-    readonly handler: HandlerContainer;
-    constructor(target: string, handler: HandlerContainer);
-}
-export type CPSVisitCallback = (cpsVisit: CPSVisitCallback, context: CPSContext, stack: string[], item: ASTBase) => Promise<Operation>;
-export declare const defaultCPSVisit: CPSVisitCallback;
-export declare class CPS {
-    private readonly context;
-    private __visit;
-    constructor(context: CPSContext, cpsVisit?: CPSVisitCallback);
-    visit(item: ASTBase): Promise<Operation>;
-}