greybel-interpreter 0.5.2 → 0.5.6

package/dist/custom-types/list.d.ts

@@ -5,6 +5,7 @@ export declare class CustomListIterator implements Iterator<any> {
     constructor(value: any);
     next(): IteratorResult<any>;
 }
+export declare function itemAtIndex(list: any[], n: number): number;
 export default class CustomList extends CustomObjectType {
     static intrinsics: Map<string, Function>;
     value: any[];
@@ -13,7 +14,6 @@ export default class CustomList extends CustomObjectType {
     [Symbol.iterator](): CustomListIterator;
     concat(list: CustomList): CustomList;
     slice: (a: CustomLiteralType, b: CustomLiteralType) => CustomList;
-    toIndex(value: string): number | null;
     set(path: any[], value: any): Promise<void>;
     get(path: any[]): Promise<any>;
     getCallable(path: any[]): Promise<Callable>;

package/dist/custom-types/list.js

@@ -76,7 +76,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomListIterator = void 0;
+exports.itemAtIndex = exports.CustomListIterator = void 0;
 var operation_1 = require("../types/operation");
 var custom_type_1 = require("../types/custom-type");
 var CustomListIterator = /** @class */ (function () {
@@ -101,12 +101,21 @@ var CustomListIterator = /** @class */ (function () {
     return CustomListIterator;
 }());
 exports.CustomListIterator = CustomListIterator;
+function itemAtIndex(list, n) {
+    n = Math.trunc(n) || 0;
+    if (n < 0)
+        n += list.length;
+    if (n < 0 || n >= list.length)
+        return -1;
+    return n;
+}
+exports.itemAtIndex = itemAtIndex;
 var CustomList = /** @class */ (function (_super) {
     __extends(CustomList, _super);
     function CustomList(value) {
         var _this = _super.call(this) || this;
         _this.slice = function (a, b) {
-            return new CustomList(this.value.slice(a.valueOf(), b.valueOf()));
+            return new CustomList(this.value.slice(a === null || a === void 0 ? void 0 : a.valueOf(), b === null || b === void 0 ? void 0 : b.valueOf()));
         };
         _this.value = value;
         return _this;
@@ -120,51 +129,34 @@ var CustomList = /** @class */ (function (_super) {
     CustomList.prototype.concat = function (list) {
         return new CustomList(this.value.concat(list.value));
     };
-    CustomList.prototype.toIndex = function (value) {
-        var me = this;
-        var casted = Number(value);
-        var result = casted < 0 ? me.value.length + casted : casted;
-        if (result < 0) {
-            return null;
-        }
-        return result;
-    };
     CustomList.prototype.set = function (path, value) {
         return __awaiter(this, void 0, void 0, function () {
-            var me, traversalPath, refs, last, current, origin, index, setterIndex;
+            var me, traversalPath, refs, last, current, indexResult, sub, lastIndex;
             return __generator(this, function (_a) {
                 me = this;
                 traversalPath = [].concat(path);
                 refs = me.value;
                 last = traversalPath.pop();
                 current = traversalPath.shift();
-                origin = refs;
                 if (current != null) {
-                    index = me.toIndex(current);
-                    if (origin.hasOwnProperty(index)) {
-                        origin = origin[index];
-                        if (origin instanceof custom_type_1.CustomObjectType) {
-                            return [2 /*return*/, origin.set(traversalPath.concat([last]), value)];
+                    indexResult = itemAtIndex(refs, Number(current));
+                    if (refs.hasOwnProperty(indexResult)) {
+                        sub = refs[indexResult];
+                        if (sub instanceof custom_type_1.CustomObjectType) {
+                            return [2 /*return*/, sub.set(traversalPath.concat([last]), value)];
                         }
                     }
-                    else {
-                        throw new Error("Cannot set path ".concat(path.join('.')));
-                    }
+                    throw new Error("Cannot set path ".concat(path.join('.')));
                 }
-                if (origin) {
-                    setterIndex = me.toIndex(last);
-                    if (!origin.hasOwnProperty(setterIndex)) {
-                        throw new Error("Index error (list index ".concat(setterIndex, " out of range)"));
-                    }
-                    if (value instanceof operation_1.FunctionOperationBase) {
-                        origin[setterIndex] = value.fork(me);
-                    }
-                    else {
-                        origin[setterIndex] = value;
-                    }
+                lastIndex = itemAtIndex(refs, Number(last));
+                if (!refs.hasOwnProperty(lastIndex)) {
+                    throw new Error("Index error (list index ".concat(lastIndex, " out of range)"));
+                }
+                if (value instanceof operation_1.FunctionOperationBase) {
+                    refs[lastIndex] = value.fork(me);
                 }
                 else {
-                    throw new Error("Cannot set path ".concat(path.join('.')));
+                    refs[lastIndex] = value;
                 }
                 return [2 /*return*/];
             });
@@ -172,7 +164,7 @@ var CustomList = /** @class */ (function (_super) {
     };
     CustomList.prototype.get = function (path) {
         return __awaiter(this, void 0, void 0, function () {
-            var me, traversalPath, refs, current, currentValue, origin, index;
+            var me, traversalPath, refs, current, currentIndex, sub;
             return __generator(this, function (_a) {
                 me = this;
                 if (path.length === 0) {
@@ -181,46 +173,48 @@ var CustomList = /** @class */ (function (_super) {
                 traversalPath = [].concat(path);
                 refs = me.value;
                 current = traversalPath.shift();
-                currentValue = current.valueOf();
-                origin = refs;
-                if (currentValue != null) {
-                    index = me.toIndex(current);
-                    if (origin.hasOwnProperty(index)) {
-                        origin = origin[index];
-                        if (traversalPath.length > 0 && origin instanceof custom_type_1.CustomObjectType) {
-                            return [2 /*return*/, origin.get(traversalPath)];
+                if (current != null) {
+                    currentIndex = itemAtIndex(refs, Number(current));
+                    if (refs.hasOwnProperty(currentIndex)) {
+                        sub = refs[currentIndex];
+                        if (traversalPath.length > 0 && sub instanceof custom_type_1.CustomObjectType) {
+                            return [2 /*return*/, sub.get(traversalPath)];
+                        }
+                        if (traversalPath.length === 0) {
+                            return [2 /*return*/, sub];
                         }
                     }
-                    else if (path.length === 1 && CustomList.intrinsics.has(currentValue)) {
-                        return [2 /*return*/, CustomList.intrinsics.get(currentValue).bind(null, me)];
+                    else if (path.length === 1 && CustomList.intrinsics.has(current)) {
+                        return [2 /*return*/, CustomList.intrinsics.get(current).bind(null, me)];
                     }
                     else {
                         throw new Error("Cannot get path ".concat(path.join('.')));
                     }
                 }
-                else {
-                    return [2 /*return*/, null];
-                }
-                return [2 /*return*/, origin];
+                return [2 /*return*/, null];
             });
         });
     };
     CustomList.prototype.getCallable = function (path) {
         return __awaiter(this, void 0, void 0, function () {
-            var me, traversalPath, refs, current, origin, context, index;
+            var me, traversalPath, refs, current, currentIndex, sub;
             return __generator(this, function (_a) {
                 me = this;
                 traversalPath = [].concat(path);
                 refs = me.value;
                 current = traversalPath.shift();
-                origin = refs;
                 if (current != null) {
-                    index = me.toIndex(current);
-                    if (origin.hasOwnProperty(index)) {
-                        context = origin;
-                        origin = origin[index];
-                        if (origin instanceof custom_type_1.CustomObjectType) {
-                            return [2 /*return*/, origin.getCallable(traversalPath)];
+                    currentIndex = itemAtIndex(refs, Number(current));
+                    if (refs.hasOwnProperty(currentIndex)) {
+                        sub = refs[currentIndex];
+                        if (sub instanceof custom_type_1.CustomObjectType) {
+                            return [2 /*return*/, sub.getCallable(traversalPath)];
+                        }
+                        if (traversalPath.length === 0) {
+                            return [2 /*return*/, Promise.resolve({
+                                    origin: sub,
+                                    context: me
+                                })];
                         }
                     }
                     else if (path.length === 1 && CustomList.intrinsics.has(current)) {
@@ -234,14 +228,15 @@ var CustomList = /** @class */ (function (_super) {
                     }
                 }
                 return [2 /*return*/, {
-                        origin: origin,
-                        context: context
+                        origin: refs,
+                        context: me
                     }];
             });
         });
     };
     CustomList.prototype.callMethod = function (method) {
         var _a;
+        var _b;
         var args = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             args[_i - 1] = arguments[_i];
@@ -250,16 +245,16 @@ var CustomList = /** @class */ (function (_super) {
             throw new Error('Unexpected method length');
         }
         var me = this;
-        var member = method[0].valueOf();
+        var member = (_b = method[0]) === null || _b === void 0 ? void 0 : _b.toString();
         if (CustomList.isNumber(member)) {
-            var index = me.toIndex(member);
-            if (!me.value.hasOwnProperty(index)) {
+            var memberIndex = itemAtIndex(me.value, Number(member));
+            if (!me.value.hasOwnProperty(memberIndex)) {
                 return null;
             }
             if (method.length > 1) {
-                return (_a = me.value[index]).callMethod.apply(_a, __spreadArray([method.slice(1)], __read(args), false));
+                return (_a = me.value[memberIndex]).callMethod.apply(_a, __spreadArray([method.slice(1)], __read(args), false));
             }
-            return me.value[index];
+            return me.value[memberIndex];
         }
         if (!CustomList.intrinsics.has(member)) {
             throw new Error("Cannot access ".concat(member, " in list"));

package/dist/custom-types/map.js

@@ -93,28 +93,22 @@ var CustomMap = /** @class */ (function (_super) {
         var refs = me.value;
         var last = traversalPath.pop();
         var current = traversalPath.shift();
-        var origin = refs;
         if (current != null) {
-            if (origin.has(current)) {
-                origin = origin.get(current);
-                if (origin instanceof custom_type_1.CustomObjectType) {
-                    return origin.set(traversalPath.concat(last), value);
+            if (refs.has(current)) {
+                var sub = refs.get(current);
+                if (sub instanceof custom_type_1.CustomObjectType) {
+                    return sub.set(traversalPath.concat(last), value);
                 }
             }
             else {
                 throw new Error("Cannot set path ".concat(path.join('.')));
             }
         }
-        if (origin) {
-            if (value instanceof operation_1.FunctionOperationBase) {
-                origin.set(last, value.fork(me));
-            }
-            else {
-                origin.set(last, value);
-            }
+        if (value instanceof operation_1.FunctionOperationBase) {
+            refs.set(last, value.fork(me));
         }
         else {
-            throw new Error("Cannot set path ".concat(path.join('.')));
+            refs.set(last, value);
         }
     };
     CustomMap.prototype.get = function (path) {
@@ -125,40 +119,47 @@ var CustomMap = /** @class */ (function (_super) {
         var traversalPath = [].concat(path);
         var refs = me.value;
         var current = traversalPath.shift();
-        var currentValue = current.valueOf();
-        var origin = refs;
-        if (currentValue != null) {
-            if (origin.has(currentValue)) {
-                origin = origin.get(currentValue);
-                if (traversalPath.length > 0 && origin instanceof custom_type_1.CustomObjectType) {
-                    return origin.get(traversalPath);
+        if (current != null) {
+            if (refs.has(current)) {
+                var sub = refs.get(current);
+                if (traversalPath.length > 0 && sub instanceof custom_type_1.CustomObjectType) {
+                    return sub.get(traversalPath);
+                }
+                if (traversalPath.length === 0) {
+                    return sub;
                 }
             }
-            else if (path.length === 1 && CustomMap.intrinsics.has(currentValue)) {
-                return Promise.resolve(CustomMap.intrinsics.get(currentValue).bind(null, me));
+            else if (path.length === 1 && CustomMap.intrinsics.has(current)) {
+                return Promise.resolve(CustomMap.intrinsics.get(current).bind(null, me));
             }
             else {
                 throw new Error("Cannot get path ".concat(path.join('.')));
             }
         }
-        else {
-            return null;
-        }
-        return Promise.resolve(origin);
+        return Promise.resolve(null);
     };
     CustomMap.prototype.getCallable = function (path) {
         var me = this;
+        if (path.length === 0) {
+            return Promise.resolve({
+                origin: me.value,
+                context: me
+            });
+        }
         var traversalPath = [].concat(path);
         var refs = me.value;
         var current = traversalPath.shift();
-        var origin = refs;
-        var context;
         if (current != null) {
-            if (origin.has(current)) {
-                context = origin;
-                origin = origin.get(current);
-                if (origin instanceof custom_type_1.CustomObjectType) {
-                    return origin.getCallable(traversalPath);
+            if (refs.has(current)) {
+                var sub = refs.get(current);
+                if (sub instanceof custom_type_1.CustomObjectType) {
+                    return sub.getCallable(traversalPath);
+                }
+                if (traversalPath.length === 0) {
+                    return Promise.resolve({
+                        origin: sub,
+                        context: me
+                    });
                 }
             }
             else if (path.length === 1 && CustomMap.intrinsics.has(current)) {
@@ -171,13 +172,11 @@ var CustomMap = /** @class */ (function (_super) {
                 throw new Error("Cannot get path ".concat(path.join('.')));
             }
         }
-        return Promise.resolve({
-            origin: origin,
-            context: context
-        });
+        return Promise.resolve(null);
     };
     CustomMap.prototype.callMethod = function (method) {
         var _a;
+        var _b;
         var args = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             args[_i - 1] = arguments[_i];
@@ -186,7 +185,7 @@ var CustomMap = /** @class */ (function (_super) {
             throw new Error('Unexpected method length');
         }
         var me = this;
-        var key = method[0].valueOf();
+        var key = (_b = method[0]) === null || _b === void 0 ? void 0 : _b.toString();
         if (method.length > 1) {
             if (me.value.has(key)) {
                 return (_a = me.value.get(key)).callMethod.apply(_a, __spreadArray([method.slice(1)], __read(args), false));

package/dist/custom-types/string.js

@@ -75,7 +75,7 @@ var CustomString = /** @class */ (function (_super) {
         return !Number.isNaN(Number(value));
     };
     CustomString.prototype.slice = function (a, b) {
-        return new CustomString(this.value.slice(a.valueOf(), b.valueOf()));
+        return new CustomString(this.value.slice(a === null || a === void 0 ? void 0 : a.valueOf(), b === null || b === void 0 ? void 0 : b.valueOf()));
     };
     CustomString.prototype[Symbol.iterator] = function () {
         return new CustomStringIterator(this.value);

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

@@ -162,7 +162,7 @@ var LogicalAndBinaryExpression = /** @class */ (function (_super) {
                     case 0:
                         me = this;
                         evaluate = function (node) { return __awaiter(_this, void 0, void 0, function () {
-                            var expr, _a, binaryResult, _b, _c, _d, logicalResult, _e, _f, _g;
+                            var expr, _a, binaryResult, _b, _c, _d, logicalLeft, logicalResult, _e, _f, _g;
                             return __generator(this, function (_h) {
                                 switch (_h.label) {
                                     case 0:
@@ -189,11 +189,20 @@ var LogicalAndBinaryExpression = /** @class */ (function (_super) {
                                     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 5: return [4 /*yield*/, evaluate(expr.left)];
                                     case 6:
-                                        _g = [_h.sent()];
+                                        logicalLeft = _h.sent();
+                                        if ((0, typer_1.isCustomList)(logicalLeft) && !logicalLeft.valueOf()) {
+                                            logicalLeft = false;
+                                        }
+                                        if (expr.operator === greybel_core_1.Operator.And && !(0, exports.toPrimitive)(logicalLeft)) {
+                                            return [2 /*return*/, false];
+                                        }
+                                        else if (expr.operator === greybel_core_1.Operator.Or && (0, exports.toPrimitive)(logicalLeft)) {
+                                            return [2 /*return*/, true];
+                                        }
+                                        _f = (_e = exports.OPERATIONS)[expr.operator];
+                                        _g = [logicalLeft];
                                         return [4 /*yield*/, evaluate(expr.right)];
                                     case 7:
                                         logicalResult = _f.apply(_e, _g.concat([_h.sent()]));

package/dist/expressions/path.js

@@ -50,11 +50,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressionSegment = exports.PathSegment = exports.IndexSegment = exports.SliceSegment = void 0;
 var greyscript_core_1 = require("greyscript-core");
 var operation_1 = require("../types/operation");
 var expression_1 = require("../types/expression");
+var function_1 = __importDefault(require("../operations/function"));
 var typer_1 = require("../typer");
 var SliceSegment = /** @class */ (function () {
     function SliceSegment(left, right) {
@@ -194,7 +198,7 @@ var PathExpression = /** @class */ (function (_super) {
                         me = this;
                         evaluate = function (node) {
                             return __awaiter(this, void 0, void 0, function () {
-                                var traverselPath, traversedPath, position, handle, current, functionContext, origin, value, left, right;
+                                var traverselPath, traversedPath, position, handle, current, functionContext, origin, value, origin, left, right;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0:
@@ -203,22 +207,22 @@ var PathExpression = /** @class */ (function (_super) {
                                             position = 0;
                                             _a.label = 1;
                                         case 1:
-                                            if (!(current = traverselPath.shift())) return [3 /*break*/, 28];
+                                            if (!(current = traverselPath.shift())) return [3 /*break*/, 30];
                                             if (!(0, typer_1.isCustomValue)(current)) return [3 /*break*/, 2];
                                             handle = current;
-                                            return [3 /*break*/, 27];
+                                            return [3 /*break*/, 29];
                                         case 2:
                                             if (!(current instanceof expression_1.Expression)) return [3 /*break*/, 4];
                                             return [4 /*yield*/, current.get(operationContext, me.expr)];
                                         case 3:
                                             handle = _a.sent();
-                                            return [3 /*break*/, 27];
+                                            return [3 /*break*/, 29];
                                         case 4:
                                             if (!(current instanceof operation_1.Operation)) return [3 /*break*/, 6];
                                             return [4 /*yield*/, current.get(operationContext)];
                                         case 5:
                                             handle = _a.sent();
-                                            return [3 /*break*/, 27];
+                                            return [3 /*break*/, 29];
                                         case 6:
                                             if (!(current instanceof PathSegment)) return [3 /*break*/, 12];
                                             if (!(current.value === 'self' && position === 0)) return [3 /*break*/, 7];
@@ -247,67 +251,77 @@ var PathExpression = /** @class */ (function (_super) {
                                             handle = _a.sent();
                                             traversedPath = [];
                                             _a.label = 11;
-                                        case 11: return [3 /*break*/, 27];
+                                        case 11: return [3 /*break*/, 29];
                                         case 12:
-                                            if (!(current instanceof IndexSegment)) return [3 /*break*/, 17];
+                                            if (!(current instanceof IndexSegment)) return [3 /*break*/, 19];
                                             current = current.value;
                                             if (!(0, typer_1.isCustomValue)(current)) return [3 /*break*/, 13];
-                                            traversedPath.push(current.valueOf());
+                                            traversedPath.push(current.toString());
                                             return [3 /*break*/, 16];
                                         case 13:
                                             if (!(current instanceof expression_1.Expression)) return [3 /*break*/, 15];
                                             return [4 /*yield*/, current.get(operationContext)];
                                         case 14:
                                             value = _a.sent();
-                                            traversedPath.push(value);
+                                            traversedPath.push(value.toString());
                                             return [3 /*break*/, 16];
                                         case 15:
                                             operationContext.debugger.raise('Unexpected index', me, current);
                                             _a.label = 16;
-                                        case 16: return [3 /*break*/, 27];
+                                        case 16:
+                                            if (!(handle && !parentExpr)) return [3 /*break*/, 18];
+                                            return [4 /*yield*/, handle.get(traversedPath, me.expr)];
                                         case 17:
-                                            if (!(current instanceof SliceSegment)) return [3 /*break*/, 26];
-                                            if (!!handle) return [3 /*break*/, 19];
+                                            origin = _a.sent();
+                                            if (origin instanceof Function || origin instanceof function_1.default) {
+                                                handle = origin;
+                                                traversedPath = [];
+                                            }
+                                            _a.label = 18;
+                                        case 18: return [3 /*break*/, 29];
+                                        case 19:
+                                            if (!(current instanceof SliceSegment)) return [3 /*break*/, 28];
+                                            if (!!handle) return [3 /*break*/, 21];
                                             return [4 /*yield*/, operationContext.get(traversedPath)];
-                                        case 18:
+                                        case 20:
                                             handle = _a.sent();
                                             traversedPath = [];
-                                            _a.label = 19;
-                                        case 19:
+                                            _a.label = 21;
+                                        case 21:
                                             if (!(0, typer_1.isCustomList)(handle) && !(0, typer_1.isCustomString)(handle)) {
                                                 operationContext.debugger.raise('Invalid type for slice', me, handle);
                                             }
                                             left = current.left;
-                                            if (!(0, typer_1.isCustomValue)(left)) return [3 /*break*/, 20];
+                                            if (!(0, typer_1.isCustomValue)(left)) return [3 /*break*/, 22];
                                             left = left;
-                                            return [3 /*break*/, 22];
-                                        case 20:
-                                            if (!(left instanceof expression_1.Expression)) return [3 /*break*/, 22];
+                                            return [3 /*break*/, 24];
+                                        case 22:
+                                            if (!(left instanceof expression_1.Expression)) return [3 /*break*/, 24];
                                             return [4 /*yield*/, left.get(operationContext)];
-                                        case 21:
+                                        case 23:
                                             left = _a.sent();
-                                            _a.label = 22;
-                                        case 22:
+                                            _a.label = 24;
+                                        case 24:
                                             right = current.right;
-                                            if (!(0, typer_1.isCustomValue)(right)) return [3 /*break*/, 23];
+                                            if (!(0, typer_1.isCustomValue)(right)) return [3 /*break*/, 25];
                                             right = right;
-                                            return [3 /*break*/, 25];
-                                        case 23:
-                                            if (!(right instanceof expression_1.Expression)) return [3 /*break*/, 25];
-                                            return [4 /*yield*/, right.get(operationContext)];
-                                        case 24:
-                                            right = _a.sent();
-                                            _a.label = 25;
-                                        case 25:
-                                            handle = handle.slice(left, right);
                                             return [3 /*break*/, 27];
+                                        case 25:
+                                            if (!(right instanceof expression_1.Expression)) return [3 /*break*/, 27];
+                                            return [4 /*yield*/, right.get(operationContext)];
                                         case 26:
-                                            operationContext.debugger.raise('Unexpected handle', me, current);
+                                            right = _a.sent();
                                             _a.label = 27;
                                         case 27:
+                                            handle = handle.slice(left, right);
+                                            return [3 /*break*/, 29];
+                                        case 28:
+                                            operationContext.debugger.raise('Unexpected handle', me, current);
+                                            _a.label = 29;
+                                        case 29:
                                             position++;
                                             return [3 /*break*/, 1];
-                                        case 28: return [2 /*return*/, {
+                                        case 30: return [2 /*return*/, {
                                                 handle: handle,
                                                 path: traversedPath
                                             }];

package/package.json

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