greybel-interpreter 3.0.3 → 3.1.0

package/dist/operations/assign-self.d.ts

@@ -0,0 +1,11 @@
+import { ASTAssignmentStatement } from 'miniscript-core';
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class AssignSelf extends Operation {
+    readonly item: ASTAssignmentStatement;
+    right: Operation;
+    constructor(item: ASTAssignmentStatement, target?: string);
+    build(visit: CPSVisit): Promise<Operation>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/assign-self.js

@@ -0,0 +1,41 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignSelf = void 0;
+const default_1 = require("../types/default");
+const function_1 = require("./function");
+const operation_1 = require("./operation");
+class AssignSelf extends operation_1.Operation {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.right = yield visit(this.item.init);
+            return this;
+        });
+    }
+    handle(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rightValue;
+            if (this.right instanceof function_1.FunctionOperation) {
+                rightValue = yield this.right.handle(ctx, true);
+            }
+            else {
+                rightValue = yield this.right.handle(ctx);
+            }
+            ctx.functionState.context = rightValue;
+            return default_1.DefaultType.Void;
+        });
+    }
+}
+exports.AssignSelf = AssignSelf;

package/dist/operations/assign.js

@@ -11,6 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Assign = void 0;
 const default_1 = require("../types/default");
+const create_resolve_1 = require("../utils/create-resolve");
+const function_1 = require("./function");
 const operation_1 = require("./operation");
 const resolve_1 = require("./resolve");
 class Assign extends operation_1.Operation {
@@ -20,7 +22,7 @@ class Assign extends operation_1.Operation {
     }
     build(visit) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.left = new resolve_1.Resolve(this.item.variable);
+            this.left = (0, create_resolve_1.createResolve)(this.item.variable, this.target);
             yield this.left.build(visit);
             this.right = yield visit(this.item.init);
             return this;
@@ -28,11 +30,22 @@ class Assign extends operation_1.Operation {
     }
     handle(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
+            const exitObserver = ctx.processState.createExitObserver();
             const resolveResult = yield this.left.getResult(ctx);
-            if (ctx.isExit()) {
+            exitObserver.close();
+            if (exitObserver.occured()) {
                 return default_1.DefaultType.Void;
             }
-            const rightValue = yield this.right.handle(ctx);
+            if (resolveResult.path.count() === 0) {
+                throw new Error('Resolve path cannot be empty.');
+            }
+            let rightValue;
+            if (this.right instanceof function_1.FunctionOperation) {
+                rightValue = yield this.right.handle(ctx, true);
+            }
+            else {
+                rightValue = yield this.right.handle(ctx);
+            }
             if (!(resolveResult.handle instanceof resolve_1.ResolveNil)) {
                 const resultValueCtx = resolveResult.handle;
                 resultValueCtx.set(resolveResult.path, rightValue);

package/dist/operations/block.js

@@ -32,13 +32,15 @@ class Block extends operation_1.Operation {
             else if (ctx.type === context_1.ContextType.Function) {
                 isEOL = () => ctx.functionState.isReturn;
             }
+            const exitObserver = ctx.processState.createExitObserver();
             for (let index = 0; index < this.stack.length; index++) {
-                if (isEOL() || ctx.isExit()) {
+                if (isEOL() || exitObserver.occured()) {
                     break;
                 }
                 const op = this.stack[index];
                 yield ctx.step(op);
             }
+            exitObserver.close();
             return default_1.DefaultType.Void;
         });
     }

package/dist/operations/call.js

@@ -12,9 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Call = void 0;
 const default_1 = require("../types/default");
 const function_1 = require("../types/function");
-const map_1 = require("../types/map");
+const create_resolve_1 = require("../utils/create-resolve");
 const operation_1 = require("./operation");
-const resolve_1 = require("./resolve");
 class Call extends operation_1.Operation {
     constructor(item, target) {
         super(null, target);
@@ -22,7 +21,7 @@ class Call extends operation_1.Operation {
     }
     build(visit) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.fnRef = new resolve_1.Resolve(this.item.base);
+            this.fnRef = (0, create_resolve_1.createResolve)(this.item.base, this.target);
             yield this.fnRef.build(visit);
             const args = this.item.arguments.map((arg) => visit(arg));
             this.args = yield Promise.all(args);
@@ -31,21 +30,30 @@ class Call extends operation_1.Operation {
     }
     handle(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
+            const exitObserver = ctx.processState.createExitObserver();
             const resolveResult = yield this.fnRef.getResult(ctx);
-            if (ctx.isExit()) {
+            if (exitObserver.occured()) {
+                exitObserver.close();
                 return default_1.DefaultType.Void;
             }
             const valueRef = yield this.fnRef.handle(ctx, resolveResult, false);
             const fnArgs = [];
             for (let index = 0; index < this.args.length; index++) {
+                if (exitObserver.occured()) {
+                    exitObserver.close();
+                    return default_1.DefaultType.Void;
+                }
                 fnArgs.push(yield this.args[index].handle(ctx));
             }
+            if (exitObserver.occured()) {
+                exitObserver.close();
+                return default_1.DefaultType.Void;
+            }
+            exitObserver.close();
             if (valueRef instanceof function_1.CustomFunction) {
                 const func = valueRef;
-                if (this.fnRef.path.isSuper() &&
-                    ctx.functionState.context &&
-                    resolveResult.handle instanceof map_1.CustomMap) {
-                    return func.run(ctx.functionState.context, fnArgs, ctx, resolveResult.handle.getIsa());
+                if (this.fnRef.path.isSuper() && ctx.functionState.context) {
+                    return func.run(ctx.functionState.context, fnArgs, ctx);
                 }
                 return func.run(resolveResult.handle, fnArgs, ctx);
             }

package/dist/operations/chunk.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Chunk = void 0;
-const string_1 = require("../types/string");
 const block_1 = require("./block");
 const operation_1 = require("./operation");
 class Chunk extends operation_1.OperationBlock {
@@ -26,7 +25,6 @@ class Chunk extends operation_1.OperationBlock {
         });
     }
     handle(ctx) {
-        ctx.set(new string_1.CustomString('locals'), ctx.locals.scope);
         return this.block.handle(ctx);
     }
 }

package/dist/operations/evaluate.js

@@ -330,7 +330,7 @@ class Evaluate extends operation_1.Operation {
                     case miniscript_core_1.ASTType.IsaExpression: {
                         const left = yield this.resolve(ctx, expr.left);
                         const right = yield this.resolve(ctx, expr.right);
-                        return new boolean_1.CustomBoolean(left.instanceOf(right));
+                        return new boolean_1.CustomBoolean(left.instanceOf(right, ctx.contextTypeIntrinsics));
                     }
                     case miniscript_core_1.ASTType.BinaryExpression:
                         return this.resolveBinaryExpression(ctx, expr);

package/dist/operations/for.js

@@ -43,6 +43,7 @@ class For extends operation_1.OperationBlock {
                 return Promise.resolve(default_1.DefaultType.Void);
             }
             const loopState = new context_1.LoopState();
+            const exitObserver = ctx.processState.createExitObserver();
             forCtx.loopState = loopState;
             return new Promise((resolve, reject) => {
                 const iterator = iteratorValue[Symbol.iterator]();
@@ -52,6 +53,7 @@ class For extends operation_1.OperationBlock {
                 const iteration = () => __awaiter(this, void 0, void 0, function* () {
                     try {
                         if (iteratorResult.done) {
+                            exitObserver.close();
                             resolve(default_1.DefaultType.Void);
                             return;
                         }
@@ -62,7 +64,8 @@ class For extends operation_1.OperationBlock {
                         yield this.block.handle(forCtx);
                         if (loopState.isBreak ||
                             forCtx.functionState.isReturn ||
-                            ctx.isExit()) {
+                            exitObserver.occured()) {
+                            exitObserver.close();
                             resolve(default_1.DefaultType.Void);
                             return;
                         }
@@ -72,6 +75,7 @@ class For extends operation_1.OperationBlock {
                         (0, set_immediate_1.setImmediate)(iteration);
                     }
                     catch (err) {
+                        exitObserver.close();
                         reject(err);
                     }
                 });

package/dist/operations/function-reference.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionReference = void 0;
 const default_1 = require("../types/default");
+const create_resolve_1 = require("../utils/create-resolve");
 const operation_1 = require("./operation");
 const resolve_1 = require("./resolve");
 class FunctionReference extends operation_1.Operation {
@@ -20,15 +21,17 @@ class FunctionReference extends operation_1.Operation {
     }
     build(visit) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.ref = new resolve_1.Resolve(this.item.argument);
+            this.ref = (0, create_resolve_1.createResolve)(this.item.argument, this.target);
             yield this.ref.build(visit);
             return this;
         });
     }
     handle(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
+            const exitObserver = ctx.processState.createExitObserver();
             const refResult = yield this.ref.getResult(ctx);
-            if (ctx.isExit()) {
+            exitObserver.close();
+            if (exitObserver.occured()) {
                 return default_1.DefaultType.Void;
             }
             if (!(refResult.handle instanceof resolve_1.ResolveNil)) {
@@ -36,7 +39,7 @@ class FunctionReference extends operation_1.Operation {
                     return refResult.handle;
                 }
                 const customValueCtx = refResult.handle;
-                return customValueCtx.get(refResult.path);
+                return customValueCtx.get(refResult.path, ctx.contextTypeIntrinsics);
             }
             return ctx.get(refResult.path);
         });

package/dist/operations/function.d.ts

@@ -15,5 +15,5 @@ export declare class FunctionOperation extends Operation {
     args: FunctionOperationArgument[];
     constructor(item: ASTFunctionStatement, target?: string);
     build(visit: CPSVisit): Promise<Operation>;
-    handle(ctx: OperationContext): Promise<CustomValue>;
+    handle(ctx: OperationContext, assignOuter?: boolean): Promise<CustomValue>;
 }

package/dist/operations/function.js

@@ -15,6 +15,7 @@ const context_1 = require("../context");
 const default_1 = require("../types/default");
 const function_1 = require("../types/function");
 const string_1 = require("../types/string");
+const with_intrinsics_1 = require("../types/with-intrinsics");
 const block_1 = require("./block");
 const operation_1 = require("./operation");
 const reference_1 = require("./reference");
@@ -53,24 +54,27 @@ class FunctionOperation extends operation_1.Operation {
             return this;
         });
     }
-    handle(ctx) {
-        const func = new function_1.CustomFunction(ctx, 'anonymous', (fnCtx, self, args, next) => __awaiter(this, void 0, void 0, function* () {
+    handle(ctx, assignOuter = false) {
+        const func = new function_1.CustomFunction(ctx, 'anonymous', (fnCtx, self, args) => __awaiter(this, void 0, void 0, function* () {
             const functionState = new context_1.FunctionState();
-            fnCtx.set(exports.SELF_PROPERTY, self);
             functionState.context = self;
+            if (self instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
+                fnCtx.set(exports.SELF_PROPERTY, self);
+            }
+            const next = func.getNextContext();
             if (next) {
                 fnCtx.set(exports.SUPER_PROPERTY, next);
                 functionState.super = next;
             }
-            fnCtx.set(new string_1.CustomString('locals'), fnCtx.locals.scope);
-            fnCtx.set(new string_1.CustomString('outer'), fnCtx.previous.locals.scope);
             for (const [key, value] of args) {
+                if (key === function_1.SELF_NAMESPACE)
+                    continue;
                 fnCtx.set(new string_1.CustomString(key), value);
             }
             fnCtx.functionState = functionState;
             yield this.block.handle(fnCtx);
             return functionState.value;
-        }));
+        }), [], assignOuter);
         for (const item of this.args) {
             func.addArgument(item.name, item.op);
         }

package/dist/operations/if-statement.js

@@ -67,14 +67,19 @@ class IfStatement extends operation_1.OperationBlock {
     }
     handle(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
+            const exitObserver = ctx.processState.createExitObserver();
             for (let index = 0; index < this.clauses.length; index++) {
                 const clause = this.clauses[index];
                 const clauseResult = yield ctx.step(clause.condition);
+                if (exitObserver.occured()) {
+                    break;
+                }
                 if (clauseResult.toTruthy()) {
                     yield clause.block.handle(ctx);
                     break;
                 }
             }
+            exitObserver.close();
             return default_1.DefaultType.Void;
         });
     }

package/dist/operations/import.js

@@ -45,7 +45,7 @@ class Import extends operation_1.Operation {
             importCtx.locals.scope.set(exports.MODULE_PROPERTY, new map_1.CustomMap());
             yield this.top.handle(importCtx);
             const item = importCtx.locals.scope.has(exports.EXPORTS_PATH)
-                ? importCtx.scope.get(exports.EXPORTS_PATH)
+                ? importCtx.scope.get(exports.EXPORTS_PATH, ctx.contextTypeIntrinsics)
                 : default_1.DefaultType.Void;
             const identifier = this.item.name;
             ctx.set(new string_1.CustomString(identifier.name), item);

package/dist/operations/reference-globals.d.ts

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceGlobals extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceGlobals>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-globals.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceGlobals = void 0;
+const operation_1 = require("./operation");
+class ReferenceGlobals extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.globals.scope);
+    }
+}
+exports.ReferenceGlobals = ReferenceGlobals;

package/dist/operations/reference-locals.d.ts

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceLocals extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceLocals>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-locals.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceLocals = void 0;
+const operation_1 = require("./operation");
+class ReferenceLocals extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.locals.scope);
+    }
+}
+exports.ReferenceLocals = ReferenceLocals;

package/dist/operations/reference-outer.d.ts

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceOuter extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceOuter>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-outer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceOuter = void 0;
+const operation_1 = require("./operation");
+class ReferenceOuter extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.outer.scope);
+    }
+}
+exports.ReferenceOuter = ReferenceOuter;

package/dist/operations/reference-self.d.ts

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceSelf extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceSelf>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-self.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceSelf = void 0;
+const operation_1 = require("./operation");
+class ReferenceSelf extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.functionState.context);
+    }
+}
+exports.ReferenceSelf = ReferenceSelf;

package/dist/operations/resolve-globals.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveGlobals extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-globals.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveGlobals = void 0;
+const resolve_1 = require("./resolve");
+class ResolveGlobals extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.globals.scope);
+        });
+    }
+}
+exports.ResolveGlobals = ResolveGlobals;

package/dist/operations/resolve-locals.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveLocals extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-locals.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveLocals = void 0;
+const resolve_1 = require("./resolve");
+class ResolveLocals extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.locals.scope);
+        });
+    }
+}
+exports.ResolveLocals = ResolveLocals;

package/dist/operations/resolve-outer.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveOuter extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-outer.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveOuter = void 0;
+const resolve_1 = require("./resolve");
+class ResolveOuter extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.outer.scope);
+        });
+    }
+}
+exports.ResolveOuter = ResolveOuter;

package/dist/operations/resolve-self.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveSelf extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-self.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveSelf = void 0;
+const resolve_1 = require("./resolve");
+class ResolveSelf extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.functionState.context);
+        });
+    }
+}
+exports.ResolveSelf = ResolveSelf;

package/dist/operations/resolve.d.ts

@@ -50,6 +50,6 @@ export declare class Resolve extends Operation {
     constructor(item: ASTBase, target?: string);
     buildProcessor(node: ASTBase, visit: CPSVisit): Promise<void>;
     build(visit: CPSVisit): Promise<Resolve>;
-    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+    getResult(ctx: OperationContext, handle?: CustomValue): Promise<ResolveResult | null>;
     handle(ctx: OperationContext, result?: ResolveResult, autoCall?: boolean): Promise<CustomValue>;
 }