greybel-interpreter 4.5.13 → 4.6.0

package/dist/bytecode-generator.js

@@ -10,1239 +10,51 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BytecodeGenerator = void 0;
+const instruction_1 = require("./bytecode-generator/instruction");
+const context_1 = require("./bytecode-generator/context");
+const statement_1 = require("./bytecode-generator/statement");
 const greybel_core_1 = require("greybel-core");
-const miniscript_core_1 = require("miniscript-core");
 const error_1 = require("./utils/error");
-const instruction_1 = require("./byte-compiler/instruction");
-const number_1 = require("./types/number");
-const boolean_1 = require("./types/boolean");
-const string_1 = require("./types/string");
-const default_1 = require("./types/default");
-const stack_1 = require("./utils/stack");
-const keywords_1 = require("./byte-compiler/keywords");
-const path_1 = require("path");
-function generateCustomValueFromASTLiteral(node) {
-    switch (node.type) {
-        case miniscript_core_1.ASTType.BooleanLiteral:
-            return new boolean_1.CustomBoolean(node.value);
-        case miniscript_core_1.ASTType.StringLiteral:
-            return new string_1.CustomString(node.value);
-        case miniscript_core_1.ASTType.NumericLiteral:
-            return new number_1.CustomNumber(node.value);
-        case miniscript_core_1.ASTType.NilLiteral:
-            return default_1.DefaultType.Void;
-        default:
-            throw new Error('Unexpected literal type.');
-    }
-}
-function unwrap(node) {
-    while (node instanceof miniscript_core_1.ASTParenthesisExpression) {
-        node = node.expression;
+const parse = function (code) {
+    try {
+        const parser = new greybel_core_1.Parser(code);
+        return parser.parseChunk();
+    }
+    catch (err) {
+        if (err instanceof error_1.PrepareError) {
+            this.handler.errorHandler.raise(err);
+        }
+        else {
+            this.handler.errorHandler.raise(new error_1.PrepareError(err.message, {
+                range: err.range,
+                target: this.context.target.peek()
+            }));
+        }
     }
-    return node;
-}
+};
 class BytecodeGenerator {
     constructor(options) {
-        var _a;
-        this.target = new stack_1.Stack(options.target);
         this.handler = options.handler;
-        this.context = new stack_1.Stack({
-            code: [],
-            jumpPoints: []
+        this.context = new context_1.Context({
+            target: options.target,
+            handler: options.handler,
+            debugMode: options.debugMode
         });
-        this.imports = new Map();
-        this.debugMode = (_a = options.debugMode) !== null && _a !== void 0 ? _a : false;
-    }
-    parse(code) {
-        try {
-            const parser = new greybel_core_1.Parser(code);
-            return parser.parseChunk();
-        }
-        catch (err) {
-            if (err instanceof error_1.PrepareError) {
-                this.handler.errorHandler.raise(err);
-            }
-            else {
-                this.handler.errorHandler.raise(new error_1.PrepareError(err.message, {
-                    range: err.range,
-                    target: this.target.peek()
-                }));
-            }
-        }
     }
     compile(code) {
         return __awaiter(this, void 0, void 0, function* () {
-            const node = this.parse(code);
-            yield this.processNode(node);
-            this.push({
+            const statementGenerator = new statement_1.BytecodeStatementGenerator(this.context, parse.bind(this));
+            const node = parse.call(this, code);
+            yield statementGenerator.process(node);
+            const mod = this.context.module.peek();
+            mod.pushCode({
                 op: instruction_1.OpCode.HALT,
-                source: this.getSourceLocation(node)
+                source: mod.getSourceLocation(node)
             });
             return {
-                code: this.context.peek().code,
-                imports: this.imports
-            };
-        });
-    }
-    getCurrentPointer() {
-        return this.context.peek().code.length - 1;
-    }
-    getSourceLocation(node, name) {
-        const target = this.target.peek();
-        return {
-            name: name !== null && name !== void 0 ? name : node.type,
-            path: target,
-            start: node.start,
-            end: node.end
-        };
-    }
-    getInternalLocation() {
-        return {
-            name: 'internal',
-            path: 'internal',
-            start: { line: 0, character: 0 },
-            end: { line: 0, character: 0 }
-        };
-    }
-    pushContext() {
-        this.context.push({
-            code: [],
-            jumpPoints: []
-        });
-    }
-    popContext() {
-        return this.context.pop();
-    }
-    getLastJumpPoint() {
-        const jumpPoints = this.context.peek().jumpPoints;
-        if (jumpPoints.length === 0) {
-            return null;
-        }
-        return jumpPoints[jumpPoints.length - 1];
-    }
-    pushJumppoint(start, end) {
-        this.context.peek().jumpPoints.push([start, end]);
-    }
-    popJumppoint() {
-        return this.context.peek().jumpPoints.pop();
-    }
-    push(item) {
-        item.ip = this.getCurrentPointer() + 1;
-        this.context.peek().code.push(item);
-    }
-    processNode(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.debugMode) {
-                this.push({
-                    op: instruction_1.OpCode.BREAKPOINT,
-                    source: this.getSourceLocation(node)
-                });
-            }
-            switch (node.type) {
-                case miniscript_core_1.ASTType.MemberExpression:
-                    yield this.processMemberExpression(node, { isCommand: true });
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.IndexExpression:
-                    yield this.processIndexExpression(node, { isCommand: true });
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.SliceExpression:
-                    yield this.processSliceExpression(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.Identifier:
-                    yield this.processIdentifier(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.AssignmentStatement:
-                    yield this.processAssignmentStatement(node);
-                    return;
-                case miniscript_core_1.ASTType.Chunk:
-                    const chunk = node;
-                    for (const item of chunk.body) {
-                        yield this.processNode(item);
-                    }
-                    return;
-                case miniscript_core_1.ASTType.BooleanLiteral:
-                case miniscript_core_1.ASTType.StringLiteral:
-                case miniscript_core_1.ASTType.NumericLiteral:
-                case miniscript_core_1.ASTType.NilLiteral:
-                    yield this.processLiteral(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.IsaExpression:
-                case miniscript_core_1.ASTType.BinaryExpression:
-                case miniscript_core_1.ASTType.LogicalExpression:
-                    yield this.processEvaluationExpression(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.ReturnStatement:
-                    yield this.processReturn(node);
-                    return;
-                case miniscript_core_1.ASTType.BreakStatement:
-                    yield this.processBreak(node);
-                    return;
-                case miniscript_core_1.ASTType.ContinueStatement:
-                    yield this.processContinue(node);
-                    return;
-                case miniscript_core_1.ASTType.MapConstructorExpression:
-                    yield this.processMapConstructorExpression(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.ListConstructorExpression:
-                    yield this.processListConstructorExpression(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.FunctionDeclaration:
-                    yield this.processFunctionDeclaration(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.WhileStatement:
-                    yield this.processWhileStatement(node);
-                    return;
-                case miniscript_core_1.ASTType.ParenthesisExpression:
-                    yield this.processNode(node.expression);
-                    return;
-                case miniscript_core_1.ASTType.BinaryNegatedExpression:
-                case miniscript_core_1.ASTType.UnaryExpression:
-                case miniscript_core_1.ASTType.NegationExpression:
-                    yield this.processUnaryExpression(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.CallStatement:
-                    yield this.processNode(node.expression);
-                    return;
-                case miniscript_core_1.ASTType.CallExpression:
-                    yield this.processCallExpression(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case miniscript_core_1.ASTType.IfStatement:
-                case miniscript_core_1.ASTType.IfShortcutStatement:
-                    yield this.processIfStatement(node);
-                    return;
-                case miniscript_core_1.ASTType.ForGenericStatement:
-                    yield this.processForGenericStatement(node);
-                    return;
-                case miniscript_core_1.ASTType.EmptyExpression:
-                case miniscript_core_1.ASTType.Comment:
-                    return;
-                case greybel_core_1.ASTType.FeatureEnvarExpression:
-                    yield this.processEnvarExpression(node);
-                    this.push({
-                        op: instruction_1.OpCode.POP,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                case greybel_core_1.ASTType.FeatureImportExpression:
-                    yield this.processImportExpression(node);
-                    return;
-                case greybel_core_1.ASTType.FeatureIncludeExpression:
-                    yield this.processIncludeExpression(node);
-                    return;
-                case greybel_core_1.ASTType.FeatureDebuggerExpression:
-                    yield this.processDebuggerExpression(node);
-                    return;
-                default: {
-                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
-                    throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
-                        target: this.target.peek(),
-                        range
-                    });
-                }
-            }
-        });
-    }
-    processSubNode(node, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (node.type) {
-                case miniscript_core_1.ASTType.MemberExpression:
-                    yield this.processMemberExpression(node, context);
-                    return;
-                case miniscript_core_1.ASTType.IndexExpression:
-                    yield this.processIndexExpression(node, context);
-                    return;
-                case miniscript_core_1.ASTType.SliceExpression:
-                    yield this.processSliceExpression(node);
-                    return;
-                case miniscript_core_1.ASTType.Identifier:
-                    yield this.processIdentifier(node);
-                    return;
-                case miniscript_core_1.ASTType.BooleanLiteral:
-                case miniscript_core_1.ASTType.StringLiteral:
-                case miniscript_core_1.ASTType.NumericLiteral:
-                case miniscript_core_1.ASTType.NilLiteral:
-                    yield this.processLiteral(node);
-                    return;
-                case miniscript_core_1.ASTType.IsaExpression:
-                case miniscript_core_1.ASTType.BinaryExpression:
-                case miniscript_core_1.ASTType.LogicalExpression:
-                    yield this.processEvaluationExpression(node);
-                    return;
-                case miniscript_core_1.ASTType.MapConstructorExpression:
-                    yield this.processMapConstructorExpression(node);
-                    return;
-                case miniscript_core_1.ASTType.ListConstructorExpression:
-                    yield this.processListConstructorExpression(node);
-                    return;
-                case miniscript_core_1.ASTType.FunctionDeclaration:
-                    yield this.processFunctionDeclaration(node, context);
-                    return;
-                case miniscript_core_1.ASTType.ParenthesisExpression:
-                    yield this.processSubNode(node.expression);
-                    return;
-                case miniscript_core_1.ASTType.BinaryNegatedExpression:
-                case miniscript_core_1.ASTType.UnaryExpression:
-                case miniscript_core_1.ASTType.NegationExpression:
-                    yield this.processUnaryExpression(node);
-                    return;
-                case miniscript_core_1.ASTType.CallStatement:
-                    yield this.processNode(node.expression);
-                    return;
-                case miniscript_core_1.ASTType.CallExpression:
-                    yield this.processCallExpression(node);
-                    return;
-                case miniscript_core_1.ASTType.EmptyExpression:
-                    this.push({
-                        op: instruction_1.OpCode.PUSH,
-                        source: this.getSourceLocation(node),
-                        value: default_1.DefaultType.Void
-                    });
-                    return;
-                case greybel_core_1.ASTType.FeatureEnvarExpression:
-                    yield this.processEnvarExpression(node);
-                    return;
-                case greybel_core_1.ASTType.FeatureLineExpression:
-                    this.push({
-                        op: instruction_1.OpCode.PUSH,
-                        source: this.getSourceLocation(node),
-                        value: new number_1.CustomNumber(node.start.line)
-                    });
-                    return;
-                case greybel_core_1.ASTType.FeatureFileExpression:
-                    this.push({
-                        op: instruction_1.OpCode.PUSH,
-                        source: this.getSourceLocation(node),
-                        value: new string_1.CustomString((0, path_1.basename)(this.target.peek()))
-                    });
-                    return;
-                case miniscript_core_1.ASTType.Comment:
-                    return;
-                default: {
-                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
-                    throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
-                        target: this.target.peek(),
-                        range
-                    });
-                }
-            }
-        });
-    }
-    processMemberExpression(node, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const base = unwrap(node.base);
-            if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getSourceLocation(node.identifier),
-                    value: new string_1.CustomString(node.identifier.name)
-                });
-                this.push({
-                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
-                    source: this.getSourceLocation(node.identifier),
-                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference)
-                });
-            }
-            else {
-                yield this.processSubNode(base, { isCommand: !!(context === null || context === void 0 ? void 0 : context.isCommand) });
-                if (node.identifier instanceof miniscript_core_1.ASTIdentifier) {
-                    yield this.processIdentifier(node.identifier, { isDescending: true, isReference: !!(context === null || context === void 0 ? void 0 : context.isReference) });
-                }
-                else {
-                    yield this.processSubNode(node.identifier, { isCommand: !!(context === null || context === void 0 ? void 0 : context.isCommand) });
-                }
-            }
-        });
-    }
-    processIndexExpression(node, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const base = unwrap(node.base);
-            if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
-                yield this.processSubNode(node.index);
-                this.push({
-                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
-                    source: this.getSourceLocation(node.index, node.type),
-                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference) && !!(context === null || context === void 0 ? void 0 : context.isCommand)
-                });
-            }
-            else {
-                yield this.processSubNode(base, { isCommand: !!(context === null || context === void 0 ? void 0 : context.isCommand) });
-                yield this.processSubNode(node.index, { isCommand: !!(context === null || context === void 0 ? void 0 : context.isCommand) });
-                this.push({
-                    op: instruction_1.OpCode.GET_PROPERTY,
-                    source: this.getSourceLocation(node.index, node.type),
-                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference) && !!(context === null || context === void 0 ? void 0 : context.isCommand)
-                });
-            }
-        });
-    }
-    processSliceExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.processSubNode(node.base);
-            yield this.processSubNode(node.left);
-            yield this.processSubNode(node.right);
-            this.push({
-                op: instruction_1.OpCode.SLICE,
-                source: this.getSourceLocation(node)
-            });
-        });
-    }
-    processIdentifier(node, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(context === null || context === void 0 ? void 0 : context.isDescending)) {
-                switch (node.name) {
-                    case keywords_1.RuntimeKeyword.Self: {
-                        this.push({
-                            op: instruction_1.OpCode.GET_SELF,
-                            source: this.getSourceLocation(node)
-                        });
-                        return;
-                    }
-                    case keywords_1.RuntimeKeyword.Super: {
-                        this.push({
-                            op: instruction_1.OpCode.GET_SUPER,
-                            source: this.getSourceLocation(node)
-                        });
-                        return;
-                    }
-                    case keywords_1.RuntimeKeyword.Outer: {
-                        this.push({
-                            op: instruction_1.OpCode.GET_OUTER,
-                            source: this.getSourceLocation(node)
-                        });
-                        return;
-                    }
-                    case keywords_1.RuntimeKeyword.Locals: {
-                        this.push({
-                            op: instruction_1.OpCode.GET_LOCALS,
-                            source: this.getSourceLocation(node)
-                        });
-                        return;
-                    }
-                    case keywords_1.RuntimeKeyword.Globals: {
-                        this.push({
-                            op: instruction_1.OpCode.GET_GLOBALS,
-                            source: this.getSourceLocation(node)
-                        });
-                        return;
-                    }
-                    default: {
-                        this.push({
-                            op: instruction_1.OpCode.GET_VARIABLE,
-                            source: this.getSourceLocation(node),
-                            property: new string_1.CustomString(node.name),
-                            invoke: !(context === null || context === void 0 ? void 0 : context.isReference)
-                        });
-                    }
-                }
-            }
-            else {
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getSourceLocation(node),
-                    value: new string_1.CustomString(node.name)
-                });
-                this.push({
-                    op: instruction_1.OpCode.GET_PROPERTY,
-                    source: this.getSourceLocation(node),
-                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference)
-                });
-            }
-        });
-    }
-    processAssignmentStatement(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let variable = unwrap(node.variable);
-            if (variable instanceof miniscript_core_1.ASTUnaryExpression) {
-                variable = unwrap(variable.argument);
-            }
-            if (variable instanceof miniscript_core_1.ASTMemberExpression) {
-                yield this.processSubNode(variable.base);
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getSourceLocation(variable.identifier),
-                    value: new string_1.CustomString(variable.identifier.name)
-                });
-            }
-            else if (variable instanceof miniscript_core_1.ASTIndexExpression) {
-                yield this.processSubNode(variable.base);
-                yield this.processSubNode(variable.index);
-            }
-            else if (variable instanceof miniscript_core_1.ASTIdentifier) {
-                this.push({
-                    op: instruction_1.OpCode.GET_LOCALS,
-                    source: this.getSourceLocation(variable)
-                });
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getSourceLocation(variable),
-                    value: new string_1.CustomString(variable.name)
-                });
-            }
-            else {
-                yield this.processSubNode(variable);
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getSourceLocation(variable),
-                    value: default_1.DefaultType.Void
-                });
-            }
-            yield this.processSubNode(node.init, { includeOuter: true });
-            this.push({
-                op: instruction_1.OpCode.ASSIGN,
-                source: this.getSourceLocation(node)
-            });
-        });
-    }
-    processLiteral(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const value = generateCustomValueFromASTLiteral(node);
-            this.push({
-                op: instruction_1.OpCode.PUSH,
-                source: this.getSourceLocation(node),
-                value
-            });
-        });
-    }
-    processEvaluationExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const skip = {
-                op: instruction_1.OpCode.NOOP,
-                source: this.getSourceLocation(node)
-            };
-            yield this.processSubNode(node.left);
-            if (node.operator === miniscript_core_1.Operator.And) {
-                this.push({
-                    op: instruction_1.OpCode.GOTO_A_IF_FALSE_AND_PUSH,
-                    source: this.getSourceLocation(node),
-                    goto: skip
-                });
-            }
-            else if (node.operator === miniscript_core_1.Operator.Or) {
-                this.push({
-                    op: instruction_1.OpCode.GOTO_A_IF_TRUE_AND_PUSH,
-                    source: this.getSourceLocation(node),
-                    goto: skip
-                });
-            }
-            yield this.processSubNode(node.right);
-            switch (node.operator) {
-                case miniscript_core_1.Operator.Isa: {
-                    this.push({
-                        op: instruction_1.OpCode.ISA,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.Equal: {
-                    this.push({
-                        op: instruction_1.OpCode.EQUAL,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.NotEqual: {
-                    this.push({
-                        op: instruction_1.OpCode.NOT_EQUAL,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.LessThan: {
-                    this.push({
-                        op: instruction_1.OpCode.LESS_THAN,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.LessThanOrEqual: {
-                    this.push({
-                        op: instruction_1.OpCode.LESS_THAN_OR_EQUAL,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.GreaterThan: {
-                    this.push({
-                        op: instruction_1.OpCode.GREATER_THAN,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.GreaterThanOrEqual: {
-                    this.push({
-                        op: instruction_1.OpCode.GREATER_THAN_OR_EQUAL,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.And: {
-                    this.push({
-                        op: instruction_1.OpCode.AND,
-                        source: this.getSourceLocation(node)
-                    });
-                    this.push(skip);
-                    break;
-                }
-                case miniscript_core_1.Operator.Or: {
-                    this.push({
-                        op: instruction_1.OpCode.OR,
-                        source: this.getSourceLocation(node)
-                    });
-                    this.push(skip);
-                    break;
-                }
-                case miniscript_core_1.Operator.Plus: {
-                    this.push({
-                        op: instruction_1.OpCode.ADD,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.Minus: {
-                    this.push({
-                        op: instruction_1.OpCode.SUB,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.Asterik: {
-                    this.push({
-                        op: instruction_1.OpCode.MUL,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.Slash: {
-                    this.push({
-                        op: instruction_1.OpCode.DIV,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.Modulo: {
-                    this.push({
-                        op: instruction_1.OpCode.MOD,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case miniscript_core_1.Operator.Power: {
-                    this.push({
-                        op: instruction_1.OpCode.POW,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case greybel_core_1.Operator.BitwiseAnd: {
-                    this.push({
-                        op: instruction_1.OpCode.BITWISE_AND,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case greybel_core_1.Operator.BitwiseOr: {
-                    this.push({
-                        op: instruction_1.OpCode.BITWISE_OR,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case greybel_core_1.Operator.LeftShift: {
-                    this.push({
-                        op: instruction_1.OpCode.BITWISE_LEFT_SHIFT,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case greybel_core_1.Operator.RightShift: {
-                    this.push({
-                        op: instruction_1.OpCode.BITWISE_RIGHT_SHIFT,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                case greybel_core_1.Operator.UnsignedRightShift: {
-                    this.push({
-                        op: instruction_1.OpCode.BITWISE_UNSIGNED_RIGHT_SHIFT,
-                        source: this.getSourceLocation(node)
-                    });
-                    break;
-                }
-                default:
-                    throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
-            }
-        });
-    }
-    processReturn(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.context.length === 1) {
-                return;
-            }
-            if (node.argument) {
-                yield this.processSubNode(node.argument);
-            }
-            else {
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getSourceLocation(node),
-                    value: default_1.DefaultType.Void
-                });
-            }
-            this.push({
-                op: instruction_1.OpCode.RETURN,
-                source: this.getSourceLocation(node)
-            });
-        });
-    }
-    processBreak(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const jumpPoint = this.getLastJumpPoint();
-            if (jumpPoint === null)
-                return;
-            const [_, end] = jumpPoint;
-            this.push({
-                op: instruction_1.OpCode.GOTO_A,
-                source: this.getSourceLocation(node),
-                goto: end
-            });
-        });
-    }
-    processContinue(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const jumpPoint = this.getLastJumpPoint();
-            if (jumpPoint === null)
-                return;
-            const [start] = jumpPoint;
-            this.push({
-                op: instruction_1.OpCode.GOTO_A,
-                source: this.getSourceLocation(node),
-                goto: start
-            });
-        });
-    }
-    processMapConstructorExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const field of node.fields) {
-                yield this.processSubNode(field.key);
-                yield this.processSubNode(field.value);
-            }
-            this.push({
-                op: instruction_1.OpCode.CONSTRUCT_MAP,
-                source: this.getSourceLocation(node),
-                length: node.fields.length
-            });
-        });
-    }
-    processListConstructorExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const field of node.fields) {
-                yield this.processSubNode(field.value);
-            }
-            this.push({
-                op: instruction_1.OpCode.CONSTRUCT_LIST,
-                source: this.getSourceLocation(node),
-                length: node.fields.length
-            });
-        });
-    }
-    processFunctionDeclaration(node, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const args = [];
-            for (const item of node.parameters) {
-                if (item instanceof miniscript_core_1.ASTIdentifier) {
-                    args.push({
-                        name: new string_1.CustomString(item.name),
-                        defaultValue: default_1.DefaultType.Void
-                    });
-                }
-                else if (item instanceof miniscript_core_1.ASTAssignmentStatement) {
-                    let defaultValue = default_1.DefaultType.Void;
-                    if (item.init instanceof miniscript_core_1.ASTLiteral) {
-                        defaultValue = generateCustomValueFromASTLiteral(item.init);
-                    }
-                    args.push({
-                        name: new string_1.CustomString(item.variable.name),
-                        defaultValue
-                    });
-                }
-            }
-            this.pushContext();
-            for (const item of node.body) {
-                yield this.processNode(item);
-            }
-            this.push({
-                op: instruction_1.OpCode.PUSH,
-                source: this.getInternalLocation(),
-                value: default_1.DefaultType.Void
-            });
-            this.push({
-                op: instruction_1.OpCode.RETURN,
-                source: this.getInternalLocation()
-            });
-            const fnCode = this.popContext().code;
-            this.push({
-                op: instruction_1.OpCode.FUNCTION_DEFINITION,
-                source: this.getSourceLocation(node),
-                arguments: args,
-                code: fnCode,
-                /*
-                  Can be removed after MiniScript fixed outer context bug.
-                */
-                ignoreOuter: !(context === null || context === void 0 ? void 0 : context.includeOuter)
-            });
-        });
-    }
-    processWhileStatement(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const start = {
-                op: instruction_1.OpCode.NOOP,
-                source: this.getSourceLocation(node.condition)
-            };
-            const end = {
-                op: instruction_1.OpCode.NOOP,
-                source: this.getSourceLocation(node)
+                code: mod.getCode(),
+                imports: this.context.imports
             };
-            this.push(start);
-            yield this.processSubNode(node.condition);
-            this.push({
-                op: instruction_1.OpCode.GOTO_A_IF_FALSE,
-                source: this.getSourceLocation(node.condition),
-                goto: end
-            });
-            this.pushJumppoint(start, end);
-            for (const item of node.body) {
-                yield this.processNode(item);
-            }
-            this.popJumppoint();
-            this.push({
-                op: instruction_1.OpCode.GOTO_A,
-                source: this.getSourceLocation(node.condition),
-                goto: start
-            });
-            this.push(end);
-        });
-    }
-    processUnaryExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const arg = unwrap(node.argument);
-            switch (node.operator) {
-                case miniscript_core_1.Operator.Reference:
-                    if (arg instanceof miniscript_core_1.ASTMemberExpression) {
-                        yield this.processMemberExpression(arg, { isReference: true });
-                    }
-                    else if (arg instanceof miniscript_core_1.ASTIndexExpression) {
-                        yield this.processIndexExpression(arg, { isReference: true });
-                    }
-                    else if (arg instanceof miniscript_core_1.ASTIdentifier) {
-                        yield this.processIdentifier(arg, { isDescending: false, isReference: true });
-                    }
-                    else {
-                        yield this.processSubNode(arg);
-                    }
-                    return;
-                case miniscript_core_1.Operator.Not: {
-                    yield this.processSubNode(arg);
-                    this.push({
-                        op: instruction_1.OpCode.FALSIFY,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                }
-                case miniscript_core_1.Operator.Minus: {
-                    yield this.processSubNode(arg);
-                    this.push({
-                        op: instruction_1.OpCode.NEGATE,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                }
-                case miniscript_core_1.Operator.New: {
-                    yield this.processSubNode(arg);
-                    this.push({
-                        op: instruction_1.OpCode.NEW,
-                        source: this.getSourceLocation(node)
-                    });
-                    return;
-                }
-            }
-        });
-    }
-    processCallExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pushArgs = () => __awaiter(this, void 0, void 0, function* () {
-                for (const arg of node.arguments) {
-                    yield this.processSubNode(arg);
-                }
-            });
-            const left = unwrap(node.base);
-            if (left instanceof miniscript_core_1.ASTMemberExpression) {
-                const base = unwrap(left.base);
-                if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
-                    this.push({
-                        op: instruction_1.OpCode.PUSH,
-                        source: this.getSourceLocation(left.identifier),
-                        value: new string_1.CustomString(left.identifier.name)
-                    });
-                    yield pushArgs();
-                    this.push({
-                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
-                        source: this.getSourceLocation(node.base, node.type),
-                        length: node.arguments.length
-                    });
-                }
-                else {
-                    yield this.processSubNode(base);
-                    this.push({
-                        op: instruction_1.OpCode.PUSH,
-                        source: this.getSourceLocation(left.identifier),
-                        value: new string_1.CustomString(left.identifier.name)
-                    });
-                    yield pushArgs();
-                    this.push({
-                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
-                        source: this.getSourceLocation(left.identifier, node.type),
-                        length: node.arguments.length
-                    });
-                }
-            }
-            else if (left instanceof miniscript_core_1.ASTIndexExpression) {
-                const base = unwrap(left.base);
-                if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
-                    yield this.processSubNode(left.index);
-                    yield pushArgs();
-                    this.push({
-                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
-                        source: this.getSourceLocation(left.index, node.type),
-                        length: node.arguments.length
-                    });
-                }
-                else {
-                    yield this.processSubNode(base);
-                    yield this.processSubNode(left.index);
-                    yield pushArgs();
-                    this.push({
-                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
-                        source: this.getSourceLocation(left.index, node.type),
-                        length: node.arguments.length
-                    });
-                }
-            }
-            else if (left instanceof miniscript_core_1.ASTIdentifier) {
-                yield this.processIdentifier(left, { isDescending: false, isReference: true });
-                yield pushArgs();
-                this.push({
-                    op: instruction_1.OpCode.CALL,
-                    source: this.getSourceLocation(left, node.type),
-                    length: node.arguments.length
-                });
-            }
-            else {
-                yield this.processSubNode(left);
-                yield pushArgs();
-                this.push({
-                    op: instruction_1.OpCode.CALL,
-                    source: this.getSourceLocation(left, node.type),
-                    length: node.arguments.length
-                });
-            }
-        });
-    }
-    processIfStatement(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const end = {
-                op: instruction_1.OpCode.NOOP,
-                source: this.getSourceLocation(node)
-            };
-            for (const clause of node.clauses) {
-                if (clause instanceof miniscript_core_1.ASTIfClause) {
-                    const next = {
-                        op: instruction_1.OpCode.NOOP,
-                        source: this.getSourceLocation(clause)
-                    };
-                    yield this.processSubNode(clause.condition);
-                    this.push({
-                        op: instruction_1.OpCode.GOTO_A_IF_FALSE,
-                        source: this.getSourceLocation(node),
-                        goto: next
-                    });
-                    for (const item of clause.body) {
-                        yield this.processNode(item);
-                    }
-                    this.push({
-                        op: instruction_1.OpCode.GOTO_A,
-                        source: this.getSourceLocation(node),
-                        goto: end
-                    });
-                    this.push(next);
-                }
-                else if (clause instanceof miniscript_core_1.ASTElseClause) {
-                    for (const item of clause.body) {
-                        yield this.processNode(item);
-                    }
-                }
-            }
-            this.push(end);
-        });
-    }
-    processForGenericStatement(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const variable = node.variable;
-            const idxVariable = new string_1.CustomString(`__${variable.name}_idx`);
-            const start = {
-                op: instruction_1.OpCode.NEXT,
-                source: this.getSourceLocation(node.iterator),
-                idxVariable,
-                variable: new string_1.CustomString(variable.name)
-            };
-            const end = {
-                op: instruction_1.OpCode.POP_ITERATOR,
-                source: this.getSourceLocation(node.iterator)
-            };
-            this.pushJumppoint(start, end);
-            this.push({
-                op: instruction_1.OpCode.GET_LOCALS,
-                source: this.getSourceLocation(node)
-            });
-            this.push({
-                op: instruction_1.OpCode.PUSH,
-                source: this.getSourceLocation(node),
-                value: idxVariable
-            });
-            this.push({
-                op: instruction_1.OpCode.PUSH,
-                source: this.getSourceLocation(node),
-                value: new number_1.CustomNumber(-1)
-            });
-            this.push({
-                op: instruction_1.OpCode.ASSIGN,
-                source: this.getSourceLocation(node)
-            });
-            yield this.processSubNode(node.iterator);
-            this.push({
-                op: instruction_1.OpCode.PUSH_ITERATOR,
-                source: this.getSourceLocation(node.iterator)
-            });
-            this.push(start);
-            this.push({
-                op: instruction_1.OpCode.GOTO_A_IF_FALSE,
-                source: this.getSourceLocation(node.iterator),
-                goto: end
-            });
-            for (const item of node.body) {
-                yield this.processNode(item);
-            }
-            this.push({
-                op: instruction_1.OpCode.GOTO_A,
-                source: this.getSourceLocation(node.iterator),
-                goto: start
-            });
-            this.push(end);
-            this.popJumppoint();
-        });
-    }
-    processEnvarExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.push({
-                op: instruction_1.OpCode.PUSH,
-                source: this.getSourceLocation(node),
-                value: new string_1.CustomString(node.name)
-            });
-            this.push({
-                op: instruction_1.OpCode.GET_ENVAR,
-                source: this.getSourceLocation(node)
-            });
-        });
-    }
-    createImport(node, path, code) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.target.push(path);
-                this.pushContext();
-                const childNodes = this.parse(code);
-                this.push({
-                    op: instruction_1.OpCode.GET_LOCALS,
-                    source: this.getInternalLocation()
-                });
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getInternalLocation(),
-                    value: new string_1.CustomString('module')
-                });
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getInternalLocation(),
-                    value: new string_1.CustomString('exports')
-                });
-                this.push({
-                    op: instruction_1.OpCode.CONSTRUCT_MAP,
-                    source: this.getInternalLocation(),
-                    length: 0
-                });
-                this.push({
-                    op: instruction_1.OpCode.CONSTRUCT_MAP,
-                    source: this.getInternalLocation(),
-                    length: 1
-                });
-                this.push({
-                    op: instruction_1.OpCode.ASSIGN,
-                    source: this.getInternalLocation(),
-                });
-                yield this.processNode(childNodes);
-                this.push({
-                    op: instruction_1.OpCode.GET_VARIABLE,
-                    source: this.getInternalLocation(),
-                    property: new string_1.CustomString('module')
-                });
-                this.push({
-                    op: instruction_1.OpCode.PUSH,
-                    source: this.getInternalLocation(),
-                    value: new string_1.CustomString('exports')
-                });
-                this.push({
-                    op: instruction_1.OpCode.GET_PROPERTY,
-                    source: this.getInternalLocation(),
-                });
-                const context = this.popContext();
-                this.target.pop();
-                this.imports.set(path, context.code);
-            }
-            catch (err) {
-                if (err instanceof error_1.PrepareError) {
-                    throw err;
-                }
-                throw new error_1.PrepareError(err.message, {
-                    target: path,
-                    range: new miniscript_core_1.ASTRange(node.start, node.end)
-                }, err);
-            }
-        });
-    }
-    processImportExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentTarget = this.target.peek();
-            const importTarget = yield this.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
-            if (this.target.includes(importTarget)) {
-                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.start.line}. Using noop instead to prevent overflow.`);
-                return;
-            }
-            if (!this.imports.has(importTarget)) {
-                const code = yield this.handler.resourceHandler.get(importTarget);
-                if (code == null) {
-                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
-                    throw new error_1.PrepareError(`Cannot find import "${currentTarget}"`, {
-                        target: currentTarget,
-                        range
-                    });
-                }
-                yield this.createImport(node, importTarget, code);
-            }
-            this.push({
-                op: instruction_1.OpCode.GET_LOCALS,
-                source: this.getSourceLocation(node)
-            });
-            this.push({
-                op: instruction_1.OpCode.PUSH,
-                source: this.getSourceLocation(node),
-                value: new string_1.CustomString(node.name.name),
-            });
-            this.push({
-                op: instruction_1.OpCode.IMPORT,
-                source: this.getSourceLocation(node),
-                path: importTarget
-            });
-            this.push({
-                op: instruction_1.OpCode.ASSIGN,
-                source: this.getSourceLocation(node)
-            });
-        });
-    }
-    processIncludeExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentTarget = this.target.peek();
-            const importTarget = yield this.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
-            if (this.target.includes(importTarget)) {
-                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.start.line}. Using noop instead to prevent overflow.`);
-                return;
-            }
-            const code = yield this.handler.resourceHandler.get(importTarget);
-            if (code == null) {
-                const range = new miniscript_core_1.ASTRange(node.start, node.end);
-                throw new error_1.PrepareError(`Cannot find import "${currentTarget}"`, {
-                    target: currentTarget,
-                    range
-                });
-            }
-            try {
-                this.target.push(importTarget);
-                const childNodes = this.parse(code);
-                yield this.processNode(childNodes);
-                this.target.pop();
-            }
-            catch (err) {
-                if (err instanceof error_1.PrepareError) {
-                    throw err;
-                }
-                throw new error_1.PrepareError(err.message, {
-                    target: importTarget,
-                    range: new miniscript_core_1.ASTRange(node.start, node.end)
-                }, err);
-            }
-        });
-    }
-    processDebuggerExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.push({
-                op: instruction_1.OpCode.BREAKPOINT_ENABLE,
-                source: this.getSourceLocation(node)
-            });
-            this.push({
-                op: instruction_1.OpCode.BREAKPOINT,
-                source: this.getSourceLocation(node)
-            });
         });
     }
 }