greybel-interpreter 0.5.0 → 0.5.1

package/dist/expressions/logical-and-binary.js

@@ -154,58 +154,62 @@ var LogicalAndBinaryExpression = /** @class */ (function (_super) {
         });
     };
     LogicalAndBinaryExpression.prototype.get = function (operationContext) {
-        var _this = this;
-        var me = this;
-        var resolve = function (value) {
-            if ((0, typer_1.isCustomValue)(value)) {
-                return value;
-            }
-            return value.get(operationContext);
-        };
-        var evaluate = function (node) { return __awaiter(_this, void 0, void 0, function () {
-            var left, right, _a, result;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, evaluate, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        _a = node.type;
-                        switch (_a) {
-                            case greyscript_core_1.ASTType.BinaryExpression: return [3 /*break*/, 1];
-                            case greyscript_core_1.ASTType.LogicalExpression: return [3 /*break*/, 4];
-                        }
-                        return [3 /*break*/, 7];
-                    case 1: return [4 /*yield*/, resolve(node.left)];
-                    case 2:
-                        left = _b.sent();
-                        return [4 /*yield*/, resolve(node.right)];
-                    case 3:
-                        right = _b.sent();
-                        result = exports.OPERATIONS[node.operator](left, right);
-                        return [2 /*return*/, (0, typer_1.cast)(Number.isNaN(result) ? null : result)];
-                    case 4: return [4 /*yield*/, resolve(node.left)];
-                    case 5:
-                        left = _b.sent();
-                        if ((0, typer_1.isCustomList)(left) && !left.valueOf()) {
-                            left = false;
-                        }
-                        if (node.operator === greybel_core_1.Operator.And && !(0, exports.toPrimitive)(left)) {
-                            return [2 /*return*/, false];
-                        }
-                        else if (node.operator === greybel_core_1.Operator.Or && (0, exports.toPrimitive)(left)) {
-                            return [2 /*return*/, true];
-                        }
-                        return [4 /*yield*/, resolve(node.right)];
-                    case 6:
-                        right = _b.sent();
-                        return [2 /*return*/, exports.OPERATIONS[node.operator](left, right)];
-                    case 7:
-                        operationContext.debugger.raise('Unexpected expression type', me, node);
-                        _b.label = 8;
-                    case 8: return [2 /*return*/];
+                        me = this;
+                        evaluate = function (node) { return __awaiter(_this, void 0, void 0, function () {
+                            var expr, _a, binaryResult, _b, _c, _d, logicalResult, _e, _f, _g;
+                            return __generator(this, function (_h) {
+                                switch (_h.label) {
+                                    case 0:
+                                        if (!(0, typer_1.isCustomValue)(node)) return [3 /*break*/, 1];
+                                        return [2 /*return*/, node];
+                                    case 1:
+                                        if (!(node instanceof LogicalAndBinaryExpression)) return [3 /*break*/, 8];
+                                        expr = node.expr;
+                                        if (!exports.OPERATIONS[expr.operator]) {
+                                            operationContext.debugger.raise('Unexpected expression type', me, expr);
+                                        }
+                                        _a = expr.type;
+                                        switch (_a) {
+                                            case greyscript_core_1.ASTType.BinaryExpression: return [3 /*break*/, 2];
+                                            case greyscript_core_1.ASTType.LogicalExpression: return [3 /*break*/, 5];
+                                        }
+                                        return [3 /*break*/, 8];
+                                    case 2:
+                                        _c = (_b = exports.OPERATIONS)[expr.operator];
+                                        return [4 /*yield*/, evaluate(expr.left)];
+                                    case 3:
+                                        _d = [_h.sent()];
+                                        return [4 /*yield*/, evaluate(expr.right)];
+                                    case 4:
+                                        binaryResult = _c.apply(_b, _d.concat([_h.sent()]));
+                                        return [2 /*return*/, Number.isNaN(binaryResult) ? null : binaryResult];
+                                    case 5:
+                                        _f = (_e = exports.OPERATIONS)[expr.operator];
+                                        return [4 /*yield*/, evaluate(expr.left)];
+                                    case 6:
+                                        _g = [_h.sent()];
+                                        return [4 /*yield*/, evaluate(expr.right)];
+                                    case 7:
+                                        logicalResult = _f.apply(_e, _g.concat([_h.sent()]));
+                                        return [2 /*return*/, logicalResult];
+                                    case 8: return [2 /*return*/, node.get(operationContext)];
+                                }
+                            });
+                        }); };
+                        operationContext.debugger.debug('Line', me.ast.start.line, 'LogicalAndBinaryExpression', 'get', 'expr', me.expr);
+                        return [4 /*yield*/, evaluate(me)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, (0, typer_1.cast)(result)];
                 }
             });
-        }); };
-        operationContext.debugger.debug('Line', me.ast.start.line, 'LogicalAndBinaryExpression', 'get', 'expr', me.expr);
-        return evaluate(me.expr);
+        });
     };
     return LogicalAndBinaryExpression;
 }(expression_1.Expression));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greybel-interpreter",
-    "version": "0.5.0",
+    "version": "0.5.1",
     "description": "Interpreter",
     "main": "dist/index",
     "typings": "dist/index",
@@ -34,8 +34,8 @@
         "typescript": "^4.5.4"
     },
     "dependencies": {
-        "greybel-core": "^0.2.2",
-        "greyscript-core": "^0.2.3",
+        "greybel-core": "^0.2.3",
+        "greyscript-core": "^0.2.4",
         "uuid": "^8.3.2"
     },
     "keywords": [