greybel-interpreter 4.10.1 → 5.0.0

package/dist/bytecode-generator/expression.d.ts

@@ -1,5 +1,5 @@
 import { ASTFeatureEnvarExpression, ASTFeatureInjectExpression } from 'greybel-core';
-import { ASTBase, ASTCallExpression, ASTEvaluationExpression, ASTFunctionStatement, ASTIdentifier, ASTIndexExpression, ASTListConstructorExpression, ASTLiteral, ASTMapConstructorExpression, ASTMemberExpression, ASTSliceExpression, ASTUnaryExpression } from 'miniscript-core';
+import { ASTBase, ASTBinaryExpression, ASTCallExpression, ASTComparisonGroupExpression, ASTFunctionStatement, ASTIdentifier, ASTIndexExpression, ASTIsaExpression, ASTListConstructorExpression, ASTLiteral, ASTLogicalExpression, ASTMapConstructorExpression, ASTMemberExpression, ASTSliceExpression, ASTUnaryExpression } from 'miniscript-core';
 import { Context } from './context';
 import { LineCallableContext, LineContext, LineIdentifierContext } from './line';
 import { IBytecodeExpressionGenerator, IBytecodeStatementGenerator, ParseCodeFunction } from './models';
@@ -14,7 +14,10 @@ export declare class BytecodeExpressionGenerator implements IBytecodeExpressionG
     processSliceExpression(node: ASTSliceExpression): Promise<void>;
     processIdentifier(node: ASTIdentifier, context?: LineIdentifierContext): Promise<void>;
     processLiteral(node: ASTLiteral): Promise<void>;
-    processEvaluationExpression(node: ASTEvaluationExpression): Promise<void>;
+    processIsaExpression(node: ASTIsaExpression): Promise<void>;
+    processLogicalExpression(node: ASTLogicalExpression): Promise<void>;
+    private static binaryExpressionToOp;
+    processBinaryExpression(node: ASTBinaryExpression): Promise<void>;
     processMapConstructorExpression(node: ASTMapConstructorExpression): Promise<void>;
     processListConstructorExpression(node: ASTListConstructorExpression): Promise<void>;
     processFunctionDeclaration(node: ASTFunctionStatement, context?: LineContext): Promise<void>;
@@ -22,4 +25,5 @@ export declare class BytecodeExpressionGenerator implements IBytecodeExpressionG
     processCallExpression(node: ASTCallExpression): Promise<void>;
     processInjectExpression(node: ASTFeatureInjectExpression): Promise<void>;
     processEnvarExpression(node: ASTFeatureEnvarExpression): Promise<void>;
+    processComparisonGroupExpression(node: ASTComparisonGroupExpression): Promise<void>;
 }

package/dist/bytecode-generator/expression.js

@@ -48,9 +48,13 @@ class BytecodeExpressionGenerator {
                     yield this.processLiteral(node);
                     return;
                 case miniscript_core_1.ASTType.IsaExpression:
+                    yield this.processIsaExpression(node);
+                    return;
                 case miniscript_core_1.ASTType.BinaryExpression:
+                    yield this.processBinaryExpression(node);
+                    return;
                 case miniscript_core_1.ASTType.LogicalExpression:
-                    yield this.processEvaluationExpression(node);
+                    yield this.processLogicalExpression(node);
                     return;
                 case miniscript_core_1.ASTType.MapConstructorExpression:
                     yield this.processMapConstructorExpression(node);
@@ -98,6 +102,9 @@ class BytecodeExpressionGenerator {
                     return;
                 case miniscript_core_1.ASTType.Comment:
                     return;
+                case miniscript_core_1.ASTType.ComparisonGroupExpression:
+                    yield this.processComparisonGroupExpression(node);
+                    return;
                 default: {
                     const range = new miniscript_core_1.ASTRange(node.start, node.end);
                     throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
@@ -224,156 +231,65 @@ class BytecodeExpressionGenerator {
             }, node);
         });
     }
-    processEvaluationExpression(node) {
+    processIsaExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.process(node.left);
+            yield this.process(node.right);
+            if (node.type !== miniscript_core_1.ASTType.IsaExpression) {
+                throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
+            }
+            this.context.pushCode({
+                op: instruction_1.OpCode.ISA
+            }, node);
+        });
+    }
+    processLogicalExpression(node) {
         return __awaiter(this, void 0, void 0, function* () {
             const skip = {
                 op: instruction_1.OpCode.NOOP
             };
-            yield this.process(node.left);
+            let gotoOp;
+            let actionOp;
             if (node.operator === miniscript_core_1.Operator.And) {
-                this.context.pushCode({
-                    op: instruction_1.OpCode.GOTO_A_IF_FALSE_AND_PUSH,
-                    goto: skip
-                }, node);
+                gotoOp = instruction_1.OpCode.GOTO_A_IF_FALSE_AND_PUSH;
+                actionOp = instruction_1.OpCode.AND;
             }
             else if (node.operator === miniscript_core_1.Operator.Or) {
-                this.context.pushCode({
-                    op: instruction_1.OpCode.GOTO_A_IF_TRUE_AND_PUSH,
-                    goto: skip
-                }, node);
+                gotoOp = instruction_1.OpCode.GOTO_A_IF_TRUE_AND_PUSH;
+                actionOp = instruction_1.OpCode.OR;
             }
+            else {
+                throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
+            }
+            yield this.process(node.left);
+            this.context.pushCode({
+                op: gotoOp,
+                goto: skip
+            }, node);
             yield this.process(node.right);
-            switch (node.operator) {
-                case miniscript_core_1.Operator.Isa: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.ISA
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Equal: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.EQUAL
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.NotEqual: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.NOT_EQUAL
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.LessThan: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.LESS_THAN
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.LessThanOrEqual: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.LESS_THAN_OR_EQUAL
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.GreaterThan: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.GREATER_THAN
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.GreaterThanOrEqual: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.GREATER_THAN_OR_EQUAL
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.And: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.AND
-                    }, node);
-                    this.context.pushCode(skip, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Or: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.OR
-                    }, node);
-                    this.context.pushCode(skip, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Plus: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.ADD
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Minus: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.SUB
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Asterik: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.MUL
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Slash: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.DIV
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Modulo: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.MOD
-                    }, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Power: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.POW
-                    }, node);
-                    break;
-                }
-                case greybel_core_1.Operator.BitwiseAnd: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.BITWISE_AND
-                    }, node);
-                    break;
-                }
-                case greybel_core_1.Operator.BitwiseOr: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.BITWISE_OR
-                    }, node);
-                    break;
-                }
-                case greybel_core_1.Operator.LeftShift: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.BITWISE_LEFT_SHIFT
-                    }, node);
-                    break;
-                }
-                case greybel_core_1.Operator.RightShift: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.BITWISE_RIGHT_SHIFT
-                    }, node);
-                    break;
-                }
-                case greybel_core_1.Operator.UnsignedRightShift: {
-                    this.context.pushCode({
-                        op: instruction_1.OpCode.BITWISE_UNSIGNED_RIGHT_SHIFT
-                    }, node);
-                    break;
-                }
-                default:
-                    throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
+            this.context.pushCode({
+                op: actionOp
+            }, node);
+            this.context.pushCode(skip, node);
+        });
+    }
+    processBinaryExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.process(node.left);
+            yield this.process(node.right);
+            const opCode = BytecodeExpressionGenerator.binaryExpressionToOp[node.operator];
+            if (opCode == null) {
+                throw new Error(`Unexpected binary expression operator. ("${node.operator}")`);
             }
+            this.context.pushCode({
+                op: opCode
+            }, node);
         });
     }
     processMapConstructorExpression(node) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const field of node.fields) {
+            for (let index = 0; index < node.fields.length; index++) {
+                const field = node.fields[index];
                 yield this.process(field.key);
                 yield this.process(field.value);
             }
@@ -385,7 +301,8 @@ class BytecodeExpressionGenerator {
     }
     processListConstructorExpression(node) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const field of node.fields) {
+            for (let index = 0; index < node.fields.length; index++) {
+                const field = node.fields[index];
                 yield this.process(field.value);
             }
             this.context.pushCode({
@@ -397,7 +314,8 @@ class BytecodeExpressionGenerator {
     processFunctionDeclaration(node, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const args = [];
-            for (const item of node.parameters) {
+            for (let index = 0; index < node.parameters.length; index++) {
+                const item = node.parameters[index];
                 if (item instanceof miniscript_core_1.ASTIdentifier) {
                     args.push({
                         name: new string_1.CustomString(item.name),
@@ -417,7 +335,8 @@ class BytecodeExpressionGenerator {
             }
             const mod = this.context.module.peek();
             mod.pushContext();
-            for (const item of node.body) {
+            for (let index = 0; index < node.body.length; index++) {
+                const item = node.body[index];
                 yield this.stmtGenerator.process(item);
             }
             this.context.pushInternalCode({
@@ -486,7 +405,8 @@ class BytecodeExpressionGenerator {
     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) {
+                for (let index = 0; index < node.arguments.length; index++) {
+                    const arg = node.arguments[index];
                     yield this.process(arg);
                 }
             });
@@ -588,5 +508,35 @@ class BytecodeExpressionGenerator {
             }, node);
         });
     }
+    processComparisonGroupExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let index = node.expressions.length - 1; index >= 0; index--) {
+                yield this.process(node.expressions[index]);
+            }
+            this.context.pushCode({
+                op: instruction_1.OpCode.COMPARISON_GROUP,
+                operators: node.operators
+            }, node);
+        });
+    }
 }
+BytecodeExpressionGenerator.binaryExpressionToOp = {
+    [miniscript_core_1.Operator.Equal]: instruction_1.OpCode.EQUAL,
+    [miniscript_core_1.Operator.NotEqual]: instruction_1.OpCode.NOT_EQUAL,
+    [miniscript_core_1.Operator.LessThan]: instruction_1.OpCode.LESS_THAN,
+    [miniscript_core_1.Operator.LessThanOrEqual]: instruction_1.OpCode.LESS_THAN_OR_EQUAL,
+    [miniscript_core_1.Operator.GreaterThan]: instruction_1.OpCode.GREATER_THAN,
+    [miniscript_core_1.Operator.GreaterThanOrEqual]: instruction_1.OpCode.GREATER_THAN_OR_EQUAL,
+    [miniscript_core_1.Operator.Plus]: instruction_1.OpCode.ADD,
+    [miniscript_core_1.Operator.Minus]: instruction_1.OpCode.SUB,
+    [miniscript_core_1.Operator.Asterik]: instruction_1.OpCode.MUL,
+    [miniscript_core_1.Operator.Slash]: instruction_1.OpCode.DIV,
+    [miniscript_core_1.Operator.Modulo]: instruction_1.OpCode.MOD,
+    [miniscript_core_1.Operator.Power]: instruction_1.OpCode.POW,
+    [greybel_core_1.Operator.BitwiseAnd]: instruction_1.OpCode.BITWISE_AND,
+    [greybel_core_1.Operator.BitwiseOr]: instruction_1.OpCode.BITWISE_OR,
+    [greybel_core_1.Operator.LeftShift]: instruction_1.OpCode.BITWISE_LEFT_SHIFT,
+    [greybel_core_1.Operator.RightShift]: instruction_1.OpCode.BITWISE_RIGHT_SHIFT,
+    [greybel_core_1.Operator.UnsignedRightShift]: instruction_1.OpCode.BITWISE_UNSIGNED_RIGHT_SHIFT
+};
 exports.BytecodeExpressionGenerator = BytecodeExpressionGenerator;

package/dist/bytecode-generator/instruction.d.ts

@@ -40,26 +40,27 @@ export declare enum OpCode {
     LESS_THAN_OR_EQUAL = 34,
     GREATER_THAN = 35,
     GREATER_THAN_OR_EQUAL = 36,
-    AND = 37,
-    OR = 38,
-    RETURN = 39,
-    FUNCTION_DEFINITION = 40,
-    GOTO_A = 41,
-    GOTO_A_IF_FALSE = 42,
-    GOTO_A_IF_FALSE_AND_PUSH = 43,
-    GOTO_A_IF_TRUE = 44,
-    GOTO_A_IF_TRUE_AND_PUSH = 45,
-    PUSH_ITERATOR = 46,
-    POP_ITERATOR = 47,
-    NEXT = 48,
-    BITWISE_OR = 49,
-    BITWISE_AND = 50,
-    BITWISE_LEFT_SHIFT = 51,
-    BITWISE_RIGHT_SHIFT = 52,
-    BITWISE_UNSIGNED_RIGHT_SHIFT = 53,
-    BREAKPOINT = 54,
-    BREAKPOINT_ENABLE = 55,
-    IMPORT = 56
+    COMPARISON_GROUP = 37,
+    AND = 38,
+    OR = 39,
+    RETURN = 40,
+    FUNCTION_DEFINITION = 41,
+    GOTO_A = 42,
+    GOTO_A_IF_FALSE = 43,
+    GOTO_A_IF_FALSE_AND_PUSH = 44,
+    GOTO_A_IF_TRUE = 45,
+    GOTO_A_IF_TRUE_AND_PUSH = 46,
+    PUSH_ITERATOR = 47,
+    POP_ITERATOR = 48,
+    NEXT = 49,
+    BITWISE_OR = 50,
+    BITWISE_AND = 51,
+    BITWISE_LEFT_SHIFT = 52,
+    BITWISE_RIGHT_SHIFT = 53,
+    BITWISE_UNSIGNED_RIGHT_SHIFT = 54,
+    BREAKPOINT = 55,
+    BREAKPOINT_ENABLE = 56,
+    IMPORT = 57
 }
 export interface FunctionDefinitionInstructionArgument {
     name: CustomString;
@@ -127,4 +128,8 @@ export interface ImportInstruction extends BaseInstruction {
     op: OpCode.IMPORT;
     path: string;
 }
-export type Instruction = BaseInstruction | GetVariableInstruction | PushInstruction | ConstructMapInstruction | ConstructListInstruction | FunctionDefinitionInstruction | GotoAInstruction | GetPropertyInstruction | CallInstruction | NextInstruction | CallInternalInstruction | ImportInstruction;
+export interface ComparisonGroupInstruction extends BaseInstruction {
+    op: OpCode.COMPARISON_GROUP;
+    operators: string[];
+}
+export type Instruction = BaseInstruction | GetVariableInstruction | PushInstruction | ConstructMapInstruction | ConstructListInstruction | FunctionDefinitionInstruction | GotoAInstruction | GetPropertyInstruction | CallInstruction | NextInstruction | CallInternalInstruction | ImportInstruction | ComparisonGroupInstruction;

package/dist/bytecode-generator/instruction.js

@@ -40,24 +40,25 @@ var OpCode;
     OpCode[OpCode["LESS_THAN_OR_EQUAL"] = 34] = "LESS_THAN_OR_EQUAL";
     OpCode[OpCode["GREATER_THAN"] = 35] = "GREATER_THAN";
     OpCode[OpCode["GREATER_THAN_OR_EQUAL"] = 36] = "GREATER_THAN_OR_EQUAL";
-    OpCode[OpCode["AND"] = 37] = "AND";
-    OpCode[OpCode["OR"] = 38] = "OR";
-    OpCode[OpCode["RETURN"] = 39] = "RETURN";
-    OpCode[OpCode["FUNCTION_DEFINITION"] = 40] = "FUNCTION_DEFINITION";
-    OpCode[OpCode["GOTO_A"] = 41] = "GOTO_A";
-    OpCode[OpCode["GOTO_A_IF_FALSE"] = 42] = "GOTO_A_IF_FALSE";
-    OpCode[OpCode["GOTO_A_IF_FALSE_AND_PUSH"] = 43] = "GOTO_A_IF_FALSE_AND_PUSH";
-    OpCode[OpCode["GOTO_A_IF_TRUE"] = 44] = "GOTO_A_IF_TRUE";
-    OpCode[OpCode["GOTO_A_IF_TRUE_AND_PUSH"] = 45] = "GOTO_A_IF_TRUE_AND_PUSH";
-    OpCode[OpCode["PUSH_ITERATOR"] = 46] = "PUSH_ITERATOR";
-    OpCode[OpCode["POP_ITERATOR"] = 47] = "POP_ITERATOR";
-    OpCode[OpCode["NEXT"] = 48] = "NEXT";
-    OpCode[OpCode["BITWISE_OR"] = 49] = "BITWISE_OR";
-    OpCode[OpCode["BITWISE_AND"] = 50] = "BITWISE_AND";
-    OpCode[OpCode["BITWISE_LEFT_SHIFT"] = 51] = "BITWISE_LEFT_SHIFT";
-    OpCode[OpCode["BITWISE_RIGHT_SHIFT"] = 52] = "BITWISE_RIGHT_SHIFT";
-    OpCode[OpCode["BITWISE_UNSIGNED_RIGHT_SHIFT"] = 53] = "BITWISE_UNSIGNED_RIGHT_SHIFT";
-    OpCode[OpCode["BREAKPOINT"] = 54] = "BREAKPOINT";
-    OpCode[OpCode["BREAKPOINT_ENABLE"] = 55] = "BREAKPOINT_ENABLE";
-    OpCode[OpCode["IMPORT"] = 56] = "IMPORT";
+    OpCode[OpCode["COMPARISON_GROUP"] = 37] = "COMPARISON_GROUP";
+    OpCode[OpCode["AND"] = 38] = "AND";
+    OpCode[OpCode["OR"] = 39] = "OR";
+    OpCode[OpCode["RETURN"] = 40] = "RETURN";
+    OpCode[OpCode["FUNCTION_DEFINITION"] = 41] = "FUNCTION_DEFINITION";
+    OpCode[OpCode["GOTO_A"] = 42] = "GOTO_A";
+    OpCode[OpCode["GOTO_A_IF_FALSE"] = 43] = "GOTO_A_IF_FALSE";
+    OpCode[OpCode["GOTO_A_IF_FALSE_AND_PUSH"] = 44] = "GOTO_A_IF_FALSE_AND_PUSH";
+    OpCode[OpCode["GOTO_A_IF_TRUE"] = 45] = "GOTO_A_IF_TRUE";
+    OpCode[OpCode["GOTO_A_IF_TRUE_AND_PUSH"] = 46] = "GOTO_A_IF_TRUE_AND_PUSH";
+    OpCode[OpCode["PUSH_ITERATOR"] = 47] = "PUSH_ITERATOR";
+    OpCode[OpCode["POP_ITERATOR"] = 48] = "POP_ITERATOR";
+    OpCode[OpCode["NEXT"] = 49] = "NEXT";
+    OpCode[OpCode["BITWISE_OR"] = 50] = "BITWISE_OR";
+    OpCode[OpCode["BITWISE_AND"] = 51] = "BITWISE_AND";
+    OpCode[OpCode["BITWISE_LEFT_SHIFT"] = 52] = "BITWISE_LEFT_SHIFT";
+    OpCode[OpCode["BITWISE_RIGHT_SHIFT"] = 53] = "BITWISE_RIGHT_SHIFT";
+    OpCode[OpCode["BITWISE_UNSIGNED_RIGHT_SHIFT"] = 54] = "BITWISE_UNSIGNED_RIGHT_SHIFT";
+    OpCode[OpCode["BREAKPOINT"] = 55] = "BREAKPOINT";
+    OpCode[OpCode["BREAKPOINT_ENABLE"] = 56] = "BREAKPOINT_ENABLE";
+    OpCode[OpCode["IMPORT"] = 57] = "IMPORT";
 })(OpCode = exports.OpCode || (exports.OpCode = {}));

package/dist/bytecode-generator/models.d.ts

@@ -1,5 +1,5 @@
 import { ASTFeatureEnvarExpression, ASTFeatureImportExpression, ASTFeatureIncludeExpression, ASTFeatureInjectExpression } from 'greybel-core';
-import { ASTAssignmentStatement, ASTBase, ASTCallExpression, ASTEvaluationExpression, ASTForGenericStatement, ASTFunctionStatement, ASTIdentifier, ASTIfStatement, ASTIndexExpression, ASTListConstructorExpression, ASTLiteral, ASTMapConstructorExpression, ASTMemberExpression, ASTReturnStatement, ASTSliceExpression, ASTUnaryExpression, ASTWhileStatement } from 'miniscript-core';
+import { ASTAssignmentStatement, ASTBase, ASTBinaryExpression, ASTCallExpression, ASTComparisonGroupExpression, ASTForGenericStatement, ASTFunctionStatement, ASTIdentifier, ASTIfStatement, ASTIndexExpression, ASTIsaExpression, ASTListConstructorExpression, ASTLiteral, ASTLogicalExpression, ASTMapConstructorExpression, ASTMemberExpression, ASTReturnStatement, ASTSliceExpression, ASTUnaryExpression, ASTWhileStatement } from 'miniscript-core';
 import { LineCallableContext, LineContext, LineIdentifierContext } from './line';
 export interface ParseCodeFunction {
     (code: string): ASTBase;
@@ -10,7 +10,6 @@ export interface IBytecodeStatementGenerator {
     processIndexExpression(node: ASTIndexExpression, context?: LineCallableContext): Promise<void>;
     processIdentifier(node: ASTIdentifier, context?: LineIdentifierContext): Promise<void>;
     processAssignmentStatement(node: ASTAssignmentStatement): Promise<void>;
-    processEvaluationExpression(node: ASTEvaluationExpression): Promise<void>;
     processReturn(node: ASTReturnStatement): Promise<void>;
     processBreak(node: ASTBase): Promise<void>;
     processContinue(node: ASTBase): Promise<void>;
@@ -32,7 +31,9 @@ export interface IBytecodeExpressionGenerator {
     processSliceExpression(node: ASTSliceExpression): Promise<void>;
     processIdentifier(node: ASTIdentifier, context?: LineIdentifierContext): Promise<void>;
     processLiteral(node: ASTLiteral): Promise<void>;
-    processEvaluationExpression(node: ASTEvaluationExpression): Promise<void>;
+    processBinaryExpression(node: ASTBinaryExpression): Promise<void>;
+    processIsaExpression(node: ASTIsaExpression): Promise<void>;
+    processLogicalExpression(node: ASTLogicalExpression): Promise<void>;
     processMapConstructorExpression(node: ASTMapConstructorExpression): Promise<void>;
     processListConstructorExpression(node: ASTListConstructorExpression): Promise<void>;
     processFunctionDeclaration(node: ASTFunctionStatement, context?: LineContext): Promise<void>;
@@ -40,4 +41,5 @@ export interface IBytecodeExpressionGenerator {
     processCallExpression(node: ASTCallExpression): Promise<void>;
     processInjectExpression(node: ASTFeatureInjectExpression): Promise<void>;
     processEnvarExpression(node: ASTFeatureEnvarExpression): Promise<void>;
+    processComparisonGroupExpression(node: ASTComparisonGroupExpression): Promise<void>;
 }

package/dist/bytecode-generator/statement.d.ts

@@ -1,5 +1,5 @@
 import { ASTFeatureImportExpression, ASTFeatureIncludeExpression } from 'greybel-core';
-import { ASTAssignmentStatement, ASTBase, ASTCallExpression, ASTEvaluationExpression, ASTForGenericStatement, ASTIdentifier, ASTIfStatement, ASTIndexExpression, ASTListConstructorExpression, ASTMapConstructorExpression, ASTMemberExpression, ASTReturnStatement, ASTUnaryExpression, ASTWhileStatement } from 'miniscript-core';
+import { ASTAssignmentStatement, ASTBase, ASTCallExpression, ASTForGenericStatement, ASTIdentifier, ASTIfStatement, ASTIndexExpression, ASTListConstructorExpression, ASTMapConstructorExpression, ASTMemberExpression, ASTReturnStatement, ASTUnaryExpression, ASTWhileStatement } from 'miniscript-core';
 import { Context } from './context';
 import { LineCallableContext, LineIdentifierContext } from './line';
 import { IBytecodeExpressionGenerator, IBytecodeStatementGenerator, ParseCodeFunction } from './models';
@@ -13,7 +13,6 @@ export declare class BytecodeStatementGenerator implements IBytecodeStatementGen
     processIndexExpression(node: ASTIndexExpression, context?: LineCallableContext): Promise<void>;
     processIdentifier(node: ASTIdentifier, context?: LineIdentifierContext): Promise<void>;
     processAssignmentStatement(node: ASTAssignmentStatement): Promise<void>;
-    processEvaluationExpression(node: ASTEvaluationExpression): Promise<void>;
     processReturn(node: ASTReturnStatement): Promise<void>;
     processBreak(node: ASTBase): Promise<void>;
     processContinue(node: ASTBase): Promise<void>;

package/dist/bytecode-generator/statement.js

@@ -51,9 +51,8 @@ class BytecodeStatementGenerator {
                     return;
                 case miniscript_core_1.ASTType.Chunk: {
                     const chunk = node;
-                    for (const item of chunk.body) {
-                        yield this.process(item);
-                    }
+                    for (let index = 0; index < chunk.body.length; yield this.process(chunk.body[index++]))
+                        ;
                     return;
                 }
                 case miniscript_core_1.ASTType.BooleanLiteral:
@@ -63,8 +62,9 @@ class BytecodeStatementGenerator {
                     return;
                 case miniscript_core_1.ASTType.IsaExpression:
                 case miniscript_core_1.ASTType.BinaryExpression:
+                    return;
                 case miniscript_core_1.ASTType.LogicalExpression:
-                    yield this.processEvaluationExpression(node);
+                    yield this.exprGenerator.processLogicalExpression(node);
                     return;
                 case miniscript_core_1.ASTType.ReturnStatement:
                     yield this.processReturn(node);
@@ -95,7 +95,7 @@ class BytecodeStatementGenerator {
                     yield this.processUnaryExpression(node);
                     return;
                 case miniscript_core_1.ASTType.CallStatement:
-                    yield this.process(node.expression);
+                    yield this.processCallExpression(node.expression);
                     return;
                 case miniscript_core_1.ASTType.CallExpression:
                     yield this.processCallExpression(node);
@@ -251,56 +251,6 @@ class BytecodeStatementGenerator {
             }, node);
         });
     }
-    processEvaluationExpression(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const skip = {
-                op: instruction_1.OpCode.NOOP
-            };
-            yield this.exprGenerator.process(node.left);
-            if (node.operator === miniscript_core_1.Operator.And) {
-                this.context.pushCode({
-                    op: instruction_1.OpCode.GOTO_A_IF_FALSE,
-                    goto: skip
-                }, node);
-            }
-            else if (node.operator === miniscript_core_1.Operator.Or) {
-                this.context.pushCode({
-                    op: instruction_1.OpCode.GOTO_A_IF_TRUE,
-                    goto: skip
-                }, node);
-            }
-            yield this.process(node.right);
-            switch (node.operator) {
-                case miniscript_core_1.Operator.And:
-                case miniscript_core_1.Operator.Or: {
-                    this.context.pushCode(skip, node);
-                    break;
-                }
-                case miniscript_core_1.Operator.Isa:
-                case miniscript_core_1.Operator.Equal:
-                case miniscript_core_1.Operator.NotEqual:
-                case miniscript_core_1.Operator.LessThan:
-                case miniscript_core_1.Operator.LessThanOrEqual:
-                case miniscript_core_1.Operator.GreaterThan:
-                case miniscript_core_1.Operator.GreaterThanOrEqual:
-                case miniscript_core_1.Operator.Plus:
-                case miniscript_core_1.Operator.Minus:
-                case miniscript_core_1.Operator.Asterik:
-                case miniscript_core_1.Operator.Slash:
-                case miniscript_core_1.Operator.Modulo:
-                case miniscript_core_1.Operator.Power:
-                case greybel_core_1.Operator.BitwiseAnd:
-                case greybel_core_1.Operator.BitwiseOr:
-                case greybel_core_1.Operator.LeftShift:
-                case greybel_core_1.Operator.RightShift:
-                case greybel_core_1.Operator.UnsignedRightShift: {
-                    break;
-                }
-                default:
-                    throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
-            }
-        });
-    }
     processReturn(node) {
         return __awaiter(this, void 0, void 0, function* () {
             const mod = this.context.module.peek();
@@ -352,7 +302,8 @@ class BytecodeStatementGenerator {
     }
     processMapConstructorExpression(node) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const field of node.fields) {
+            for (let index = 0; index < node.fields.length; index++) {
+                const field = node.fields[index];
                 yield this.exprGenerator.process(field.key);
                 yield this.exprGenerator.process(field.value);
             }
@@ -365,7 +316,8 @@ class BytecodeStatementGenerator {
     }
     processListConstructorExpression(node) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const field of node.fields) {
+            for (let index = 0; index < node.fields.length; index++) {
+                const field = node.fields[index];
                 yield this.exprGenerator.process(field.value);
             }
             this.context.pushCode({
@@ -391,9 +343,8 @@ class BytecodeStatementGenerator {
                 goto: end
             }, node.condition);
             mod.pushJumppoint(start, end);
-            for (const item of node.body) {
-                yield this.process(item);
-            }
+            for (let index = 0; index < node.body.length; yield this.process(node.body[index++]))
+                ;
             mod.popJumppoint();
             this.context.pushCode({
                 op: instruction_1.OpCode.GOTO_A,
@@ -452,7 +403,8 @@ class BytecodeStatementGenerator {
     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) {
+                for (let index = 0; index < node.arguments.length; index++) {
+                    const arg = node.arguments[index];
                     yield this.exprGenerator.process(arg);
                 }
             });
@@ -535,7 +487,8 @@ class BytecodeStatementGenerator {
             const end = {
                 op: instruction_1.OpCode.NOOP
             };
-            for (const clause of node.clauses) {
+            for (let index = 0; index < node.clauses.length; index++) {
+                const clause = node.clauses[index];
                 if (clause instanceof miniscript_core_1.ASTIfClause) {
                     const next = {
                         op: instruction_1.OpCode.NOOP
@@ -545,9 +498,8 @@ class BytecodeStatementGenerator {
                         op: instruction_1.OpCode.GOTO_A_IF_FALSE,
                         goto: next
                     }, node);
-                    for (const item of clause.body) {
-                        yield this.process(item);
-                    }
+                    for (let index = 0; index < clause.body.length; yield this.process(clause.body[index++]))
+                        ;
                     this.context.pushCode({
                         op: instruction_1.OpCode.GOTO_A,
                         goto: end
@@ -555,9 +507,8 @@ class BytecodeStatementGenerator {
                     this.context.pushCode(next, clause);
                 }
                 else if (clause instanceof miniscript_core_1.ASTElseClause) {
-                    for (const item of clause.body) {
-                        yield this.process(item);
-                    }
+                    for (let index = 0; index < clause.body.length; yield this.process(clause.body[index++]))
+                        ;
                 }
             }
             this.context.pushCode(end, node);
@@ -600,9 +551,8 @@ class BytecodeStatementGenerator {
                 op: instruction_1.OpCode.GOTO_A_IF_FALSE,
                 goto: end
             }, node.iterator);
-            for (const item of node.body) {
-                yield this.process(item);
-            }
+            for (let index = 0; index < node.body.length; yield this.process(node.body[index++]))
+                ;
             this.context.pushCode({
                 op: instruction_1.OpCode.GOTO_A,
                 goto: start

package/dist/vm/evaluation.d.ts

@@ -25,3 +25,4 @@ export declare function evalMod(a: CustomValue, b: CustomValue): CustomNil | Cus
 export declare function evalPow(a: CustomValue, b: CustomValue): CustomNil | CustomNumber;
 export declare function evalAnd(a: CustomValue, b: CustomValue): CustomNumber;
 export declare function evalOr(a: CustomValue, b: CustomValue): CustomNumber;
+export declare function evalComparisonGroup(values: CustomValue[], operators: string[]): CustomNumber;

package/dist/vm/evaluation.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evalOr = exports.evalAnd = exports.evalPow = exports.evalMod = exports.evalNotEqual = exports.evalEqual = exports.evalGreaterThanOrEqual = exports.evalGreaterThan = exports.evalLessThanOrEqual = exports.evalLessThan = exports.evalBitwiseLeftShift = exports.evalBitwiseUnsignedRightShift = exports.evalBitwiseRightShift = exports.evalBitwiseAnd = exports.evalBitwiseOr = exports.evalDiv = exports.evalMul = exports.evalSub = exports.evalAdd = exports.absClamp01 = void 0;
+exports.evalComparisonGroup = exports.evalOr = exports.evalAnd = exports.evalPow = exports.evalMod = exports.evalNotEqual = exports.evalEqual = exports.evalGreaterThanOrEqual = exports.evalGreaterThan = exports.evalLessThanOrEqual = exports.evalLessThan = exports.evalBitwiseLeftShift = exports.evalBitwiseUnsignedRightShift = exports.evalBitwiseRightShift = exports.evalBitwiseAnd = exports.evalBitwiseOr = exports.evalDiv = exports.evalMul = exports.evalSub = exports.evalAdd = exports.absClamp01 = void 0;
+const miniscript_core_1 = require("miniscript-core");
 const boolean_1 = require("../types/boolean");
 const default_1 = require("../types/default");
 const function_1 = require("../types/function");
@@ -340,3 +341,36 @@ function evalOr(a, b) {
     return new number_1.CustomNumber((0, exports.absClamp01)(left + right - left * right));
 }
 exports.evalOr = evalOr;
+function evalComparisonGroup(values, operators) {
+    for (let index = 0; index < operators.length; index++) {
+        const operator = operators[index];
+        const left = values[index];
+        const right = values[index + 1];
+        let result;
+        switch (operator) {
+            case miniscript_core_1.Operator.Equal:
+                result = evalEqual(left, right);
+                break;
+            case miniscript_core_1.Operator.NotEqual:
+                result = evalNotEqual(left, right);
+                break;
+            case miniscript_core_1.Operator.GreaterThan:
+                result = evalGreaterThan(left, right);
+                break;
+            case miniscript_core_1.Operator.GreaterThanOrEqual:
+                result = evalGreaterThanOrEqual(left, right);
+                break;
+            case miniscript_core_1.Operator.LessThan:
+                result = evalLessThan(left, right);
+                break;
+            case miniscript_core_1.Operator.LessThanOrEqual:
+                result = evalLessThanOrEqual(left, right);
+                break;
+        }
+        if (!result.toTruthy()) {
+            return default_1.DefaultType.False;
+        }
+    }
+    return default_1.DefaultType.True;
+}
+exports.evalComparisonGroup = evalComparisonGroup;

package/dist/vm.js

@@ -176,22 +176,28 @@ class VM {
             return new Promise((resolve, reject) => {
                 this.state = VMState.PENDING;
                 this.time = Date.now();
-                this.resume((err) => {
+                this.signal.on('done', (err) => {
+                    this.signal.removeAllListeners('cycle');
+                    this.signal.removeAllListeners('resume');
+                    this.signal.removeAllListeners('done');
                     if (err) {
                         reject(err);
                         return;
                     }
                     resolve();
                 });
+                this.signal.on('cycle', () => (0, non_blocking_schedule_1.schedule)(() => this.resume()));
+                this.signal.on('resume', () => this.resume());
+                this.resume();
             });
         });
     }
-    resume(done) {
+    resume() {
         var _a, _b, _c, _d, _e;
         try {
             while (true) {
                 if (!this.isPending()) {
-                    done();
+                    this.signal.emit('done');
                     return;
                 }
                 const frame = this.getFrame();
@@ -357,42 +363,40 @@ class VM {
                     }
                     case instruction_1.OpCode.GOTO_A_IF_FALSE: {
                         const condition = this.popStack();
-                        if (condition.toTruthy()) {
-                            break;
+                        const value = condition instanceof number_1.CustomNumber ? (0, evaluation_1.absClamp01)(condition.value) : +condition.toTruthy();
+                        if (value === 0) {
+                            const gotoAInstruction = instruction;
+                            frame.ip = gotoAInstruction.goto.ip;
                         }
-                        const gotoAInstruction = instruction;
-                        frame.ip = gotoAInstruction.goto.ip;
                         break;
                     }
                     case instruction_1.OpCode.GOTO_A_IF_FALSE_AND_PUSH: {
                         const condition = this.popStack();
                         const value = condition instanceof number_1.CustomNumber ? (0, evaluation_1.absClamp01)(condition.value) : +condition.toTruthy();
                         this.pushStack(new number_1.CustomNumber(value));
-                        if (value >= 1) {
-                            break;
+                        if (value === 0) {
+                            const gotoAInstruction = instruction;
+                            frame.ip = gotoAInstruction.goto.ip;
                         }
-                        const gotoAInstruction = instruction;
-                        frame.ip = gotoAInstruction.goto.ip;
                         break;
                     }
                     case instruction_1.OpCode.GOTO_A_IF_TRUE: {
                         const condition = this.popStack();
-                        if (!condition.toTruthy()) {
-                            break;
+                        const value = condition instanceof number_1.CustomNumber ? (0, evaluation_1.absClamp01)(condition.value) : +condition.toTruthy();
+                        if (value === 1) {
+                            const gotoAInstruction = instruction;
+                            frame.ip = gotoAInstruction.goto.ip;
                         }
-                        const gotoAInstruction = instruction;
-                        frame.ip = gotoAInstruction.goto.ip;
                         break;
                     }
                     case instruction_1.OpCode.GOTO_A_IF_TRUE_AND_PUSH: {
                         const condition = this.popStack();
                         const value = condition instanceof number_1.CustomNumber ? (0, evaluation_1.absClamp01)(condition.value) : +condition.toTruthy();
                         this.pushStack(new number_1.CustomNumber(value));
-                        if (value < 1) {
-                            break;
+                        if (value === 1) {
+                            const gotoAInstruction = instruction;
+                            frame.ip = gotoAInstruction.goto.ip;
                         }
-                        const gotoAInstruction = instruction;
-                        frame.ip = gotoAInstruction.goto.ip;
                         break;
                     }
                     case instruction_1.OpCode.GOTO_A: {
@@ -512,8 +516,10 @@ class VM {
                         if (immediateRet === null || immediateRet === void 0 ? void 0 : immediateRet.then) {
                             immediateRet.then((ret) => {
                                 this.pushStack(ret);
-                                this.resume(done);
-                            }).catch(done);
+                                this.signal.emit('resume');
+                            }).catch((err) => {
+                                this.signal.emit('done', err);
+                            });
                             return;
                         }
                         this.pushStack(immediateRet);
@@ -587,6 +593,15 @@ class VM {
                         this.pushStack((0, evaluation_1.evalBitwiseUnsignedRightShift)(a, b));
                         break;
                     }
+                    case instruction_1.OpCode.COMPARISON_GROUP: {
+                        const comparisonGroupInstruction = instruction;
+                        const values = [];
+                        for (let index = 0; index <= comparisonGroupInstruction.operators.length; index++) {
+                            values.push(this.popStack());
+                        }
+                        this.pushStack((0, evaluation_1.evalComparisonGroup)(values, comparisonGroupInstruction.operators));
+                        break;
+                    }
                     case instruction_1.OpCode.ADD: {
                         const b = this.popStack();
                         const a = this.popStack();
@@ -689,8 +704,10 @@ class VM {
                         if (this.debugger.getBreakpoint(this)) {
                             this.debugger.interact(this, instruction.source);
                             this.debugger.resume().then(() => {
-                                this.resume(done);
-                            }).catch(done);
+                                this.signal.emit('resume');
+                            }).catch((err) => {
+                                this.signal.emit('done', err);
+                            });
                             return;
                         }
                         break;
@@ -702,21 +719,18 @@ class VM {
                     case instruction_1.OpCode.HALT: {
                         this.state = VMState.FINISHED;
                         this.signal.emit('done');
-                        done();
                         return;
                     }
                 }
                 if (this.actionCount++ === this.maxActionsPerLoop) {
                     this.actionCount = 0;
-                    (0, non_blocking_schedule_1.schedule)(() => {
-                        this.resume(done);
-                    });
+                    this.signal.emit('cycle');
                     return;
                 }
             }
         }
         catch (err) {
-            done(err);
+            this.signal.emit('done', err);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greybel-interpreter",
-  "version": "4.10.1",
+  "version": "5.0.0",
   "description": "Interpreter",
   "main": "dist/index",
   "typings": "dist/index",
@@ -49,7 +49,7 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "greybel-core": "~1.8.4",
+    "greybel-core": "~2.0.1",
     "hyperid": "^3.2.0",
     "non-blocking-schedule": "^0.1.0"
   },