greybel-interpreter 0.1.9 → 0.2.0

package/dist/expressions/assign.d.ts

@@ -7,6 +7,7 @@ export declare class ExpressionSegment {
     constructor(left: any, right: any);
 }
 export default class AssignExpression extends Expression {
-    constructor(ast: ASTAssignmentStatement, visit: Function);
+    constructor(ast: ASTAssignmentStatement);
+    prepare(visit: Function): Promise<AssignExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<any>;
 }

package/dist/expressions/assign.js

@@ -67,16 +67,34 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var AssignExpression = /** @class */ (function (_super) {
     __extends(AssignExpression, _super);
-    function AssignExpression(ast, visit) {
+    function AssignExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(visit(node.variable), visit(node.init));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    AssignExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        return [4 /*yield*/, visit(node.variable)];
+                    case 1:
+                        _c = [void 0, _d.sent()];
+                        return [4 /*yield*/, visit(node.init)];
+                    case 2:
+                        _a.expr = new (_b.apply(ExpressionSegment, _c.concat([_d.sent()])))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     AssignExpression.prototype.get = function (operationContext, parentExpr) {
         return __awaiter(this, void 0, void 0, function () {
             var me, evaluate;

package/dist/expressions/binary-negated-expression.d.ts

@@ -13,6 +13,7 @@ export declare class ExpressionSegment {
 }
 export default class BinaryNegatedExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTUnaryExpression, visit: Function);
+    constructor(ast: ASTUnaryExpression);
+    prepare(visit: Function): Promise<BinaryNegatedExpression>;
     get(operationContext: OperationContext): any;
 }

package/dist/expressions/binary-negated-expression.js

@@ -75,16 +75,32 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var BinaryNegatedExpression = /** @class */ (function (_super) {
     __extends(BinaryNegatedExpression, _super);
-    function BinaryNegatedExpression(ast, visit) {
+    function BinaryNegatedExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(node.operator, visit(node.argument));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    BinaryNegatedExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        _c = [void 0, node.operator];
+                        return [4 /*yield*/, visit(node.argument)];
+                    case 1:
+                        _a.expr = new (_b.apply(ExpressionSegment, _c.concat([_d.sent()])))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     BinaryNegatedExpression.prototype.get = function (operationContext) {
         var me = this;
         var evaluate = function (node) {

package/dist/expressions/call.d.ts

@@ -8,6 +8,7 @@ export declare class ExpressionSegment {
 }
 export default class CallExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: any, visit: Function);
+    constructor(ast: any);
+    prepare(visit: Function): Promise<CallExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<any>;
 }

package/dist/expressions/call.js

@@ -105,19 +105,48 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var CallExpression = /** @class */ (function (_super) {
     __extends(CallExpression, _super);
-    function CallExpression(ast, visit) {
+    function CallExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            if (greyscript_core_1.ASTType.CallStatement === node.type) {
-                return buildExpression(node.expression);
-            }
-            return new ExpressionSegment(visit(node.base), node.arguments.map(function (item) { return visit(item); }));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    CallExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, buildExpression, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        me = this;
+                        buildExpression = function (node) {
+                            return __awaiter(this, void 0, void 0, function () {
+                                var _a, _b;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            if (greyscript_core_1.ASTType.CallStatement === node.type) {
+                                                return [2 /*return*/, buildExpression(node.expression)];
+                                            }
+                                            _a = ExpressionSegment.bind;
+                                            return [4 /*yield*/, visit(node.base)];
+                                        case 1:
+                                            _b = [void 0, _c.sent()];
+                                            return [4 /*yield*/, Promise.all(node.arguments.map(function (item) { return visit(item); }))];
+                                        case 2: return [2 /*return*/, new (_a.apply(ExpressionSegment, _b.concat([_c.sent()])))()];
+                                    }
+                                });
+                            });
+                        };
+                        _a = me;
+                        return [4 /*yield*/, buildExpression(me.ast)];
+                    case 1:
+                        _a.expr = _b.sent();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     CallExpression.prototype.get = function (operationContext, parentExpr) {
         var me = this;
         var opc = operationContext.fork(context_1.ContextType.CALL, context_1.ContextState.TEMPORARY);

package/dist/expressions/list.d.ts

@@ -8,6 +8,7 @@ export declare class ExpressionSegment {
 }
 export default class ListExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTListConstructorExpression, visit: Function);
+    constructor(ast: ASTListConstructorExpression);
+    prepare(visit: Function): Promise<ListExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<CustomList>;
 }

package/dist/expressions/list.js

@@ -67,18 +67,33 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var ListExpression = /** @class */ (function (_super) {
     __extends(ListExpression, _super);
-    function ListExpression(ast, visit) {
+    function ListExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(node.fields.map(function (item) {
-                return visit(item.value);
-            }));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    ListExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        return [4 /*yield*/, Promise.all(node.fields.map(function (item) {
+                                return visit(item.value);
+                            }))];
+                    case 1:
+                        _a.expr = new (_b.apply(ExpressionSegment, [void 0, _c.sent()]))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     ListExpression.prototype.get = function (operationContext, parentExpr) {
         var me = this;
         var evaluate = function (node) {

package/dist/expressions/logical-and-binary.d.ts

@@ -17,6 +17,7 @@ export declare class ExpressionSegment {
 }
 export default class LogicalAndBinaryExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTEvaluationExpression, visit: Function);
+    constructor(ast: ASTEvaluationExpression);
+    prepare(visit: Function): Promise<LogicalAndBinaryExpression>;
     get(operationContext: OperationContext): Promise<any>;
 }

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

@@ -123,16 +123,36 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var LogicalAndBinaryExpression = /** @class */ (function (_super) {
     __extends(LogicalAndBinaryExpression, _super);
-    function LogicalAndBinaryExpression(ast, visit) {
+    function LogicalAndBinaryExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(node.type, node.operator, visit(node.left), visit(node.right));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    LogicalAndBinaryExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        _c = [void 0, node.type,
+                            node.operator];
+                        return [4 /*yield*/, visit(node.left)];
+                    case 1:
+                        _c = _c.concat([_d.sent()]);
+                        return [4 /*yield*/, visit(node.right)];
+                    case 2:
+                        _a.expr = new (_b.apply(ExpressionSegment, _c.concat([_d.sent()])))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     LogicalAndBinaryExpression.prototype.get = function (operationContext) {
         var _this = this;
         var me = this;

package/dist/expressions/map.d.ts

@@ -13,6 +13,7 @@ export declare class ExpressionSegment {
 }
 export default class MapExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTMapConstructorExpression, visit: Function);
+    constructor(ast: ASTMapConstructorExpression);
+    prepare(visit: Function): Promise<MapExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<CustomMap>;
 }

package/dist/expressions/map.js

@@ -87,21 +87,46 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var MapExpression = /** @class */ (function (_super) {
     __extends(MapExpression, _super);
-    function MapExpression(ast, visit) {
+    function MapExpression(ast) {
         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);
+        me.expr = null;
         return _this;
     }
+    MapExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        return [4 /*yield*/, Promise.all(node.fields.map(function (item) { return __awaiter(_this, void 0, void 0, function () {
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _a = {};
+                                            return [4 /*yield*/, visit(item.key)];
+                                        case 1:
+                                            _a.key = _b.sent();
+                                            return [4 /*yield*/, visit(item.value)];
+                                        case 2: return [2 /*return*/, (_a.value = _b.sent(),
+                                                _a)];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.expr = new (_b.apply(ExpressionSegment, [void 0, _c.sent()]))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     MapExpression.prototype.get = function (operationContext, parentExpr) {
         var me = this;
         var evaluate = function (values) {

package/dist/expressions/path.d.ts

@@ -25,6 +25,7 @@ export declare class ExpressionSegment {
 }
 export default class PathExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTBase, visit: Function);
+    constructor(ast: ASTBase);
+    prepare(visit: Function): Promise<PathExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<any>;
 }

package/dist/expressions/path.js

@@ -96,42 +96,95 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var PathExpression = /** @class */ (function (_super) {
     __extends(PathExpression, _super);
-    function PathExpression(ast, visit) {
+    function PathExpression(ast) {
         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);
+        me.expr = null;
         return _this;
     }
+    PathExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, buildExpression, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        me = this;
+                        buildExpression = function (node) {
+                            var _a;
+                            return __awaiter(this, void 0, void 0, function () {
+                                var expression, _b, memberExpression, _c, _d, _e, _f, indexExpression, _g, _h, sliceExpression, _j, _k, _l, _m, _o, _p, _q, identifier, _r, _s;
+                                return __generator(this, function (_t) {
+                                    switch (_t.label) {
+                                        case 0:
+                                            expression = new ExpressionSegment();
+                                            _b = node.type;
+                                            switch (_b) {
+                                                case greyscript_core_1.ASTType.MemberExpression: return [3 /*break*/, 1];
+                                                case greyscript_core_1.ASTType.IndexExpression: return [3 /*break*/, 4];
+                                                case greyscript_core_1.ASTType.Identifier: return [3 /*break*/, 11];
+                                            }
+                                            return [3 /*break*/, 12];
+                                        case 1:
+                                            memberExpression = node;
+                                            _d = (_c = expression).append;
+                                            return [4 /*yield*/, buildExpression(memberExpression.base)];
+                                        case 2:
+                                            _d.apply(_c, [_t.sent()]);
+                                            _f = (_e = expression).append;
+                                            return [4 /*yield*/, buildExpression(memberExpression.identifier)];
+                                        case 3:
+                                            _f.apply(_e, [_t.sent()]);
+                                            return [3 /*break*/, 14];
+                                        case 4:
+                                            indexExpression = node;
+                                            _h = (_g = expression).append;
+                                            return [4 /*yield*/, buildExpression(indexExpression.base)];
+                                        case 5:
+                                            _h.apply(_g, [_t.sent()]);
+                                            if (!(((_a = indexExpression.index) === null || _a === void 0 ? void 0 : _a.type) === 'SliceExpression')) return [3 /*break*/, 8];
+                                            sliceExpression = indexExpression.index;
+                                            _k = (_j = expression).append;
+                                            _l = SliceSegment.bind;
+                                            return [4 /*yield*/, visit(sliceExpression.left)];
+                                        case 6:
+                                            _m = [void 0, _t.sent()];
+                                            return [4 /*yield*/, visit(sliceExpression.right)];
+                                        case 7:
+                                            _k.apply(_j, [new (_l.apply(SliceSegment, _m.concat([_t.sent()])))()]);
+                                            return [3 /*break*/, 10];
+                                        case 8:
+                                            _p = (_o = expression).append;
+                                            _q = IndexSegment.bind;
+                                            return [4 /*yield*/, visit(indexExpression.index)];
+                                        case 9:
+                                            _p.apply(_o, [new (_q.apply(IndexSegment, [void 0, _t.sent()]))()]);
+                                            _t.label = 10;
+                                        case 10: return [3 /*break*/, 14];
+                                        case 11:
+                                            identifier = node;
+                                            expression.append(new PathSegment(identifier.name));
+                                            return [3 /*break*/, 14];
+                                        case 12:
+                                            _s = (_r = expression).append;
+                                            return [4 /*yield*/, visit(node)];
+                                        case 13:
+                                            _s.apply(_r, [_t.sent()]);
+                                            _t.label = 14;
+                                        case 14: return [2 /*return*/, expression];
+                                    }
+                                });
+                            });
+                        };
+                        _a = me;
+                        return [4 /*yield*/, buildExpression(me.ast)];
+                    case 1:
+                        _a.expr = _b.sent();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     PathExpression.prototype.get = function (operationContext, parentExpr) {
         return __awaiter(this, void 0, void 0, function () {
             var me, evaluate, resultExpr, context, value_1, _a, value, callable, _b;

package/dist/interpreter.d.ts

@@ -10,7 +10,7 @@ export interface InterpreterOptions {
 }
 export default class Interpreter {
     target: string;
-    code: string;
+    code: string | null;
     api: Map<string, any>;
     params: any[];
     resourceHandler: ResourceHandler;

package/dist/interpreter.js

@@ -1,4 +1,40 @@
 "use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -20,7 +56,7 @@ var Interpreter = /** @class */ (function () {
         me.context = null;
         if (options.target) {
             me.target = options.target;
-            me.code = me.resourceHandler.get(options.target);
+            me.code = null;
         }
         else {
             me.target = 'unknown';
@@ -28,28 +64,49 @@ var Interpreter = /** @class */ (function () {
         }
     }
     Interpreter.prototype.digest = function () {
-        var me = this;
-        var parser = new greybel_core_1.Parser(me.code);
-        var chunk = parser.parseChunk();
-        var cps = new cps_1.default({
-            target: me.target,
-            resourceHandler: me.resourceHandler
-        });
-        var mainContext = new context_1.OperationContext({
-            isProtected: true,
-            debugger: me.debugger,
-            cps: cps
-        });
-        var topOperation = new top_1.default(null, {
-            body: cps.visit(chunk)
-        });
-        mainContext.extend(me.api);
-        mainContext.scope.refs.set('params', (0, typer_1.cast)(me.params));
-        me.context = mainContext;
-        return topOperation.run(mainContext)
-            .catch(function (err) {
-            console.error(err);
-            throw err;
+        return __awaiter(this, void 0, void 0, function () {
+            var me, code, _a, parser, chunk, cps, mainContext, topOperation, _b, _c;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        me = this;
+                        _a = me.code;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, me.resourceHandler.get(me.target)];
+                    case 1:
+                        _a = (_e.sent());
+                        _e.label = 2;
+                    case 2:
+                        code = _a;
+                        parser = new greybel_core_1.Parser(code);
+                        chunk = parser.parseChunk();
+                        cps = new cps_1.default({
+                            target: me.target,
+                            resourceHandler: me.resourceHandler
+                        });
+                        mainContext = new context_1.OperationContext({
+                            isProtected: true,
+                            debugger: me.debugger,
+                            cps: cps
+                        });
+                        _b = top_1.default.bind;
+                        _c = [void 0, null];
+                        _d = {};
+                        return [4 /*yield*/, cps.visit(chunk)];
+                    case 3:
+                        topOperation = new (_b.apply(top_1.default, _c.concat([(_d.body = _e.sent(),
+                                _d)])))();
+                        mainContext.extend(me.api);
+                        mainContext.scope.refs.set('params', (0, typer_1.cast)(me.params));
+                        me.context = mainContext;
+                        return [2 /*return*/, topOperation.run(mainContext)
+                                .catch(function (err) {
+                                console.error(err);
+                                throw err;
+                            })];
+                }
+            });
         });
     };
     Interpreter.prototype.exit = function () {

package/dist/resource.d.ts

@@ -1,8 +1,8 @@
 export interface ResourceHandler {
-    getTargetRelativeTo(source: string, target: string): string;
-    has(target: string): boolean;
-    get(target: string): string;
-    resolve(target: string): string;
+    getTargetRelativeTo(source: string, target: string): Promise<string>;
+    has(target: string): Promise<boolean>;
+    get(target: string): Promise<string>;
+    resolve(target: string): Promise<string>;
 }
 export declare class ResourceProvider {
     getHandler(): ResourceHandler;

package/dist/resource.js

@@ -11,16 +11,16 @@ var ResourceProvider = /** @class */ (function () {
             getTargetRelativeTo: function (source, target) {
                 var base = path.resolve(source, '..');
                 var result = path.resolve(base, target);
-                return fs.existsSync(result) ? result : result + '.src';
+                return Promise.resolve(fs.existsSync(result) ? result : result + '.src');
             },
             has: function (target) {
-                return fs.existsSync(target);
+                return Promise.resolve(fs.existsSync(target));
             },
             get: function (target) {
-                return fs.readFileSync(target, 'utf8');
+                return Promise.resolve(fs.readFileSync(target, 'utf8'));
             },
             resolve: function (target) {
-                return path.resolve(target);
+                return Promise.resolve(path.resolve(target));
             }
         };
     };

package/package.json

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