greybel-interpreter 0.1.0

package/dist/expressions/map.js

@@ -0,0 +1,171 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionSegment = exports.ValuesSegment = void 0;
+var expression_1 = require("../types/expression");
+var map_1 = __importDefault(require("../custom-types/map"));
+var typer_1 = require("../typer");
+var ValuesSegment = /** @class */ (function () {
+    function ValuesSegment(key, value) {
+        var me = this;
+        me.key = key;
+        me.value = value;
+    }
+    return ValuesSegment;
+}());
+exports.ValuesSegment = ValuesSegment;
+var ExpressionSegment = /** @class */ (function () {
+    function ExpressionSegment(values) {
+        this.values = values;
+    }
+    return ExpressionSegment;
+}());
+exports.ExpressionSegment = ExpressionSegment;
+var MapExpression = /** @class */ (function (_super) {
+    __extends(MapExpression, _super);
+    function MapExpression(ast, visit) {
+        var _this = _super.call(this) || this;
+        var me = _this;
+        var buildExpression = function (node) {
+            return new ExpressionSegment(node.fields.map(function (item) {
+                return {
+                    key: visit(item.key),
+                    value: visit(item.value)
+                };
+            }));
+        };
+        me.ast = ast;
+        me.expr = buildExpression(ast);
+        return _this;
+    }
+    MapExpression.prototype.get = function (operationContext, parentExpr) {
+        var me = this;
+        var evaluate = function (values) {
+            return __awaiter(this, void 0, void 0, function () {
+                var map, values_1, values_1_1, current, key, value, e_1_1;
+                var e_1, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            map = new Map();
+                            _b.label = 1;
+                        case 1:
+                            _b.trys.push([1, 9, 10, 11]);
+                            values_1 = __values(values), values_1_1 = values_1.next();
+                            _b.label = 2;
+                        case 2:
+                            if (!!values_1_1.done) return [3 /*break*/, 8];
+                            current = values_1_1.value;
+                            key = void 0;
+                            value = void 0;
+                            if ((0, typer_1.isCustomValue)(current.key)) {
+                                key = current.key.valueOf();
+                            }
+                            else {
+                                operationContext.debugger.raise('Unexpected key', me, current.key);
+                            }
+                            if (!(0, typer_1.isCustomValue)(current.value)) return [3 /*break*/, 3];
+                            value = current.value;
+                            return [3 /*break*/, 6];
+                        case 3:
+                            if (!(current.value instanceof expression_1.Expression)) return [3 /*break*/, 5];
+                            return [4 /*yield*/, current.value.get(operationContext)];
+                        case 4:
+                            value = _b.sent();
+                            return [3 /*break*/, 6];
+                        case 5:
+                            operationContext.debugger.raise('Unexpected value', me, current.value);
+                            _b.label = 6;
+                        case 6:
+                            // @ts-ignore: Key is always a literal
+                            map.set(key, value);
+                            _b.label = 7;
+                        case 7:
+                            values_1_1 = values_1.next();
+                            return [3 /*break*/, 2];
+                        case 8: return [3 /*break*/, 11];
+                        case 9:
+                            e_1_1 = _b.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 11];
+                        case 10:
+                            try {
+                                if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                            return [7 /*endfinally*/];
+                        case 11: return [2 /*return*/, new map_1.default(map)];
+                    }
+                });
+            });
+        };
+        operationContext.debugger.debug('MapExpression', 'get', 'expr', me.expr);
+        return evaluate(me.expr.values);
+    };
+    return MapExpression;
+}(expression_1.Expression));
+exports.default = MapExpression;

package/dist/expressions/path.d.ts

@@ -0,0 +1,30 @@
+import { ASTBase } from 'greybel-core';
+import { Expression } from '../types/expression';
+import { OperationContext } from '../context';
+export interface PathEvaluationResult {
+    handle: any;
+    path: string[];
+}
+export declare class SliceSegment {
+    left: any;
+    right: any;
+    constructor(left: any, right: any);
+}
+export declare class IndexSegment {
+    value: any;
+    constructor(value: any);
+}
+export declare class PathSegment {
+    value: string;
+    constructor(value: string);
+}
+export declare class ExpressionSegment {
+    value: any[];
+    constructor();
+    append(val: any): ExpressionSegment;
+}
+export default class PathExpression extends Expression {
+    expr: ExpressionSegment;
+    constructor(ast: ASTBase, visit: Function);
+    get(operationContext: OperationContext, parentExpr: any): Promise<any>;
+}

package/dist/expressions/path.js

@@ -0,0 +1,310 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 typer_1 = require("../typer");
+var SliceSegment = /** @class */ (function () {
+    function SliceSegment(left, right) {
+        this.left = left;
+        this.right = right;
+    }
+    return SliceSegment;
+}());
+exports.SliceSegment = SliceSegment;
+var IndexSegment = /** @class */ (function () {
+    function IndexSegment(value) {
+        this.value = value;
+    }
+    return IndexSegment;
+}());
+exports.IndexSegment = IndexSegment;
+var PathSegment = /** @class */ (function () {
+    function PathSegment(value) {
+        this.value = value;
+    }
+    return PathSegment;
+}());
+exports.PathSegment = PathSegment;
+var ExpressionSegment = /** @class */ (function () {
+    function ExpressionSegment() {
+        this.value = [];
+    }
+    ExpressionSegment.prototype.append = function (val) {
+        var me = this;
+        if (val instanceof ExpressionSegment) {
+            me.value = me.value.concat(val.value);
+            return me;
+        }
+        me.value = me.value.concat(val);
+        return me;
+    };
+    return ExpressionSegment;
+}());
+exports.ExpressionSegment = ExpressionSegment;
+var PathExpression = /** @class */ (function (_super) {
+    __extends(PathExpression, _super);
+    function PathExpression(ast, visit) {
+        var _this = _super.call(this) || this;
+        var me = _this;
+        var buildExpression = function (node) {
+            var _a;
+            var expression = new ExpressionSegment();
+            switch (node.type) {
+                case greyscript_core_1.ASTType.MemberExpression:
+                    var memberExpression = node;
+                    expression.append(buildExpression(memberExpression.base));
+                    expression.append(buildExpression(memberExpression.identifier));
+                    break;
+                case greyscript_core_1.ASTType.IndexExpression:
+                    var indexExpression = node;
+                    expression.append(buildExpression(indexExpression.base));
+                    if (((_a = indexExpression.index) === null || _a === void 0 ? void 0 : _a.type) === 'SliceExpression') {
+                        var sliceExpression = indexExpression.index;
+                        expression.append(new SliceSegment(visit(sliceExpression.left), visit(sliceExpression.right)));
+                    }
+                    else {
+                        expression.append(new IndexSegment(visit(indexExpression.index)));
+                    }
+                    break;
+                case greyscript_core_1.ASTType.Identifier:
+                    var identifier = node;
+                    expression.append(new PathSegment(identifier.name));
+                    break;
+                default:
+                    expression.append(visit(node));
+            }
+            return expression;
+        };
+        me.ast = ast;
+        me.expr = buildExpression(ast);
+        return _this;
+    }
+    PathExpression.prototype.get = function (operationContext, parentExpr) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, evaluate, resultExpr, context, value_1, value, callable, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        me = this;
+                        evaluate = function (node) {
+                            return __awaiter(this, void 0, void 0, function () {
+                                var traverselPath, traversedPath, position, handle, current, functionContext, origin, value, left, right;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            traverselPath = [].concat(node.value);
+                                            traversedPath = [];
+                                            position = 0;
+                                            _a.label = 1;
+                                        case 1:
+                                            if (!(current = traverselPath.shift())) return [3 /*break*/, 28];
+                                            if (!(0, typer_1.isCustomValue)(current)) return [3 /*break*/, 2];
+                                            handle = current;
+                                            return [3 /*break*/, 27];
+                                        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];
+                                        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];
+                                        case 6:
+                                            if (!(current instanceof PathSegment)) return [3 /*break*/, 12];
+                                            if (!(current.value === 'self' && position === 0)) return [3 /*break*/, 7];
+                                            functionContext = operationContext.getMemory('functionContext');
+                                            if (functionContext === null || functionContext === void 0 ? void 0 : functionContext.context) {
+                                                handle = functionContext.context;
+                                            }
+                                            else {
+                                                operationContext.debugger.raise('Unexpected self', me, current);
+                                            }
+                                            return [3 /*break*/, 11];
+                                        case 7:
+                                            traversedPath.push(current.value);
+                                            if (!(traverselPath.length > 0)) return [3 /*break*/, 11];
+                                            return [4 /*yield*/, (handle || operationContext).get(traversedPath)];
+                                        case 8:
+                                            origin = _a.sent();
+                                            if (!(0, typer_1.isCustomValue)(origin)) return [3 /*break*/, 9];
+                                            handle = origin;
+                                            traversedPath = [];
+                                            return [3 /*break*/, 11];
+                                        case 9:
+                                            if (!(origin instanceof Function)) return [3 /*break*/, 11];
+                                            return [4 /*yield*/, origin.call(handle)];
+                                        case 10:
+                                            handle = _a.sent();
+                                            traversedPath = [];
+                                            _a.label = 11;
+                                        case 11: return [3 /*break*/, 27];
+                                        case 12:
+                                            if (!(current instanceof IndexSegment)) return [3 /*break*/, 17];
+                                            current = current.value;
+                                            if (!(0, typer_1.isCustomValue)(current)) return [3 /*break*/, 13];
+                                            traversedPath.push(current.valueOf());
+                                            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);
+                                            return [3 /*break*/, 16];
+                                        case 15:
+                                            operationContext.debugger.raise('Unexpected index', me, current);
+                                            _a.label = 16;
+                                        case 16: return [3 /*break*/, 27];
+                                        case 17:
+                                            if (!(current instanceof SliceSegment)) return [3 /*break*/, 26];
+                                            if (!!handle) return [3 /*break*/, 19];
+                                            return [4 /*yield*/, operationContext.get(traversedPath)];
+                                        case 18:
+                                            handle = _a.sent();
+                                            traversedPath = [];
+                                            _a.label = 19;
+                                        case 19:
+                                            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];
+                                            left = left;
+                                            return [3 /*break*/, 22];
+                                        case 20:
+                                            if (!(left instanceof expression_1.Expression)) return [3 /*break*/, 22];
+                                            return [4 /*yield*/, left.get(operationContext)];
+                                        case 21:
+                                            left = _a.sent();
+                                            _a.label = 22;
+                                        case 22:
+                                            right = current.right;
+                                            if (!(0, typer_1.isCustomValue)(right)) return [3 /*break*/, 23];
+                                            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 26:
+                                            operationContext.debugger.raise('Unexpected handle', me, current);
+                                            _a.label = 27;
+                                        case 27:
+                                            position++;
+                                            return [3 /*break*/, 1];
+                                        case 28: return [2 /*return*/, {
+                                                handle: handle,
+                                                path: traversedPath
+                                            }];
+                                    }
+                                });
+                            });
+                        };
+                        operationContext.debugger.debug('PathExpression', 'get', 'expr', me.expr);
+                        return [4 /*yield*/, evaluate(me.expr)];
+                    case 1:
+                        resultExpr = _b.sent();
+                        if (!!parentExpr) return [3 /*break*/, 14];
+                        if (!resultExpr.handle) return [3 /*break*/, 8];
+                        if (!(resultExpr.path.length === 0)) return [3 /*break*/, 2];
+                        return [2 /*return*/, resultExpr.handle];
+                    case 2:
+                        if (!(0, typer_1.isCustomMap)(resultExpr.handle)) return [3 /*break*/, 7];
+                        context = resultExpr.handle;
+                        return [4 /*yield*/, context.get(resultExpr.path)];
+                    case 3:
+                        value_1 = _b.sent();
+                        if (!(value_1 instanceof operation_1.Operation)) return [3 /*break*/, 4];
+                        return [2 /*return*/, value_1.run(operationContext)];
+                    case 4:
+                        if (!(value_1 instanceof Function)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, value_1.call(context)];
+                    case 5: return [2 /*return*/, _b.sent()];
+                    case 6: return [2 /*return*/, value_1];
+                    case 7: return [2 /*return*/, (0, typer_1.cast)(resultExpr.handle.callMethod(resultExpr.path))];
+                    case 8: return [4 /*yield*/, operationContext.get(resultExpr.path)];
+                    case 9:
+                        value = _b.sent();
+                        if (!(value instanceof Function)) return [3 /*break*/, 12];
+                        return [4 /*yield*/, operationContext.getCallable(resultExpr.path)];
+                    case 10:
+                        callable = _b.sent();
+                        _a = typer_1.cast;
+                        return [4 /*yield*/, callable.origin.call(callable.context)];
+                    case 11: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+                    case 12:
+                        if (value instanceof operation_1.Operation) {
+                            return [2 /*return*/, value.run(operationContext)];
+                        }
+                        _b.label = 13;
+                    case 13: return [2 /*return*/, value];
+                    case 14: return [2 /*return*/, resultExpr];
+                }
+            });
+        });
+    };
+    return PathExpression;
+}(expression_1.Expression));
+exports.default = PathExpression;

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export { default as AssignExpression } from './expressions/assign';
+export { default as CallExpression } from './expressions/call';
+export { default as ListExpression } from './expressions/list';
+export { default as LogicalAndBinaryExpression } from './expressions/logical-and-binary';
+export { default as MapExpression } from './expressions/map';
+export { default as PathExpression } from './expressions/path';
+export { default as BinaryNegatedExpression } from './expressions/binary-negated-expression';
+export { default as ArgumentOperation } from './operations/argument';
+export { default as WhileOperation } from './operations/while';
+export { default as ForOperation } from './operations/for';
+export { default as ReturnOperation } from './operations/return';
+export { default as NewOperation } from './operations/new';
+export { default as NotOperation } from './operations/not';
+export { default as IfStatementOperation } from './operations/if-statement';
+export { default as IfOperation } from './operations/if';
+export { default as ElseIfOperation } from './operations/else-if';
+export { default as ElseOperation } from './operations/else';
+export { default as ContinueOperation } from './operations/continue';
+export { default as BreakOperation } from './operations/break';
+export { default as BodyOperation } from './operations/body';
+export { default as TopOperation } from './operations/top';
+export { default as DebuggerOperation } from './operations/debugger';
+export { default as CustomBoolean } from './custom-types/boolean';
+export { default as CustomNumber } from './custom-types/number';
+export { default as CustomString } from './custom-types/string';
+export { default as CustomNil } from './custom-types/nil';
+export { default as CustomMap } from './custom-types/map';
+export { default as CustomList } from './custom-types/list';
+export * from './resource';
+export * from './context';
+export * from './types/operation';
+export * from './types/expression';
+export * from './types/custom-type';
+export { default as CPS, CPSMap, CPSMapContext, CPSMapType } from './cps';
+export { default as Interpreter, InterpreterOptions } from './interpreter';

package/dist/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interpreter = exports.CPSMap = exports.CPS = exports.CustomList = exports.CustomMap = exports.CustomNil = exports.CustomString = exports.CustomNumber = exports.CustomBoolean = exports.DebuggerOperation = exports.TopOperation = exports.BodyOperation = exports.BreakOperation = exports.ContinueOperation = exports.ElseOperation = exports.ElseIfOperation = exports.IfOperation = exports.IfStatementOperation = exports.NotOperation = exports.NewOperation = exports.ReturnOperation = exports.ForOperation = exports.WhileOperation = exports.ArgumentOperation = exports.BinaryNegatedExpression = exports.PathExpression = exports.MapExpression = exports.LogicalAndBinaryExpression = exports.ListExpression = exports.CallExpression = exports.AssignExpression = void 0;
+var assign_1 = require("./expressions/assign");
+Object.defineProperty(exports, "AssignExpression", { enumerable: true, get: function () { return __importDefault(assign_1).default; } });
+var call_1 = require("./expressions/call");
+Object.defineProperty(exports, "CallExpression", { enumerable: true, get: function () { return __importDefault(call_1).default; } });
+var list_1 = require("./expressions/list");
+Object.defineProperty(exports, "ListExpression", { enumerable: true, get: function () { return __importDefault(list_1).default; } });
+var logical_and_binary_1 = require("./expressions/logical-and-binary");
+Object.defineProperty(exports, "LogicalAndBinaryExpression", { enumerable: true, get: function () { return __importDefault(logical_and_binary_1).default; } });
+var map_1 = require("./expressions/map");
+Object.defineProperty(exports, "MapExpression", { enumerable: true, get: function () { return __importDefault(map_1).default; } });
+var path_1 = require("./expressions/path");
+Object.defineProperty(exports, "PathExpression", { enumerable: true, get: function () { return __importDefault(path_1).default; } });
+var binary_negated_expression_1 = require("./expressions/binary-negated-expression");
+Object.defineProperty(exports, "BinaryNegatedExpression", { enumerable: true, get: function () { return __importDefault(binary_negated_expression_1).default; } });
+var argument_1 = require("./operations/argument");
+Object.defineProperty(exports, "ArgumentOperation", { enumerable: true, get: function () { return __importDefault(argument_1).default; } });
+var while_1 = require("./operations/while");
+Object.defineProperty(exports, "WhileOperation", { enumerable: true, get: function () { return __importDefault(while_1).default; } });
+var for_1 = require("./operations/for");
+Object.defineProperty(exports, "ForOperation", { enumerable: true, get: function () { return __importDefault(for_1).default; } });
+var return_1 = require("./operations/return");
+Object.defineProperty(exports, "ReturnOperation", { enumerable: true, get: function () { return __importDefault(return_1).default; } });
+var new_1 = require("./operations/new");
+Object.defineProperty(exports, "NewOperation", { enumerable: true, get: function () { return __importDefault(new_1).default; } });
+var not_1 = require("./operations/not");
+Object.defineProperty(exports, "NotOperation", { enumerable: true, get: function () { return __importDefault(not_1).default; } });
+var if_statement_1 = require("./operations/if-statement");
+Object.defineProperty(exports, "IfStatementOperation", { enumerable: true, get: function () { return __importDefault(if_statement_1).default; } });
+var if_1 = require("./operations/if");
+Object.defineProperty(exports, "IfOperation", { enumerable: true, get: function () { return __importDefault(if_1).default; } });
+var else_if_1 = require("./operations/else-if");
+Object.defineProperty(exports, "ElseIfOperation", { enumerable: true, get: function () { return __importDefault(else_if_1).default; } });
+var else_1 = require("./operations/else");
+Object.defineProperty(exports, "ElseOperation", { enumerable: true, get: function () { return __importDefault(else_1).default; } });
+var continue_1 = require("./operations/continue");
+Object.defineProperty(exports, "ContinueOperation", { enumerable: true, get: function () { return __importDefault(continue_1).default; } });
+var break_1 = require("./operations/break");
+Object.defineProperty(exports, "BreakOperation", { enumerable: true, get: function () { return __importDefault(break_1).default; } });
+var body_1 = require("./operations/body");
+Object.defineProperty(exports, "BodyOperation", { enumerable: true, get: function () { return __importDefault(body_1).default; } });
+var top_1 = require("./operations/top");
+Object.defineProperty(exports, "TopOperation", { enumerable: true, get: function () { return __importDefault(top_1).default; } });
+var debugger_1 = require("./operations/debugger");
+Object.defineProperty(exports, "DebuggerOperation", { enumerable: true, get: function () { return __importDefault(debugger_1).default; } });
+var boolean_1 = require("./custom-types/boolean");
+Object.defineProperty(exports, "CustomBoolean", { enumerable: true, get: function () { return __importDefault(boolean_1).default; } });
+var number_1 = require("./custom-types/number");
+Object.defineProperty(exports, "CustomNumber", { enumerable: true, get: function () { return __importDefault(number_1).default; } });
+var string_1 = require("./custom-types/string");
+Object.defineProperty(exports, "CustomString", { enumerable: true, get: function () { return __importDefault(string_1).default; } });
+var nil_1 = require("./custom-types/nil");
+Object.defineProperty(exports, "CustomNil", { enumerable: true, get: function () { return __importDefault(nil_1).default; } });
+var map_2 = require("./custom-types/map");
+Object.defineProperty(exports, "CustomMap", { enumerable: true, get: function () { return __importDefault(map_2).default; } });
+var list_2 = require("./custom-types/list");
+Object.defineProperty(exports, "CustomList", { enumerable: true, get: function () { return __importDefault(list_2).default; } });
+__exportStar(require("./resource"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./types/operation"), exports);
+__exportStar(require("./types/expression"), exports);
+__exportStar(require("./types/custom-type"), exports);
+var cps_1 = require("./cps");
+Object.defineProperty(exports, "CPS", { enumerable: true, get: function () { return __importDefault(cps_1).default; } });
+Object.defineProperty(exports, "CPSMap", { enumerable: true, get: function () { return cps_1.CPSMap; } });
+var interpreter_1 = require("./interpreter");
+Object.defineProperty(exports, "Interpreter", { enumerable: true, get: function () { return __importDefault(interpreter_1).default; } });

package/dist/interpreter.d.ts

@@ -0,0 +1,20 @@
+import { Debugger } from './context';
+import { ResourceHandler } from './resource';
+export interface InterpreterOptions {
+    target?: string;
+    code?: string;
+    api?: Map<string, any>;
+    params?: any[];
+    resourceHandler?: ResourceHandler;
+    debugger?: Debugger;
+}
+export default class Interpreter {
+    target: string;
+    code: string;
+    api: Map<string, any>;
+    params: any[];
+    resourceHandler: ResourceHandler;
+    debugger: Debugger;
+    constructor(options: InterpreterOptions);
+    digest(): Promise<any>;
+}