greybel-interpreter 1.4.6 → 1.4.7

package/dist/operations/block.js

@@ -1,52 +1,52 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const context_1 = require("../context");
-const default_1 = __importDefault(require("../types/default"));
-const string_1 = __importDefault(require("../types/string"));
-const operation_1 = __importDefault(require("./operation"));
-class Block extends operation_1.default {
-    constructor(stack) {
-        super(null, 'block');
-        this.stack = stack;
-    }
-    build(_visit) {
-        return Promise.resolve(this);
-    }
-    handle(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isEOL = () => false;
-            if (ctx.type === context_1.ContextType.Loop) {
-                isEOL = () => ctx.loopState.isBreak || ctx.loopState.isContinue;
-            }
-            else if (ctx.type === context_1.ContextType.Function) {
-                isEOL = () => ctx.functionState.isReturn;
-            }
-            ctx.set(new string_1.default('locals'), ctx.locals.scope);
-            if (ctx.previous && ctx.previous.type !== context_1.ContextType.Api) {
-                ctx.set(new string_1.default('outer'), ctx.previous.locals.scope);
-            }
-            for (let index = 0; index < this.stack.length; index++) {
-                if (isEOL() || ctx.isExit()) {
-                    break;
-                }
-                const op = this.stack[index];
-                yield ctx.step(op);
-                yield op.handle(ctx);
-            }
-            return default_1.default.Void;
-        });
-    }
-}
-exports.default = Block;
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_1 = require("../context");
+const default_1 = __importDefault(require("../types/default"));
+const string_1 = __importDefault(require("../types/string"));
+const operation_1 = __importDefault(require("./operation"));
+class Block extends operation_1.default {
+    constructor(stack) {
+        super(null, 'block');
+        this.stack = stack;
+    }
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let isEOL = () => false;
+            if (ctx.type === context_1.ContextType.Loop) {
+                isEOL = () => ctx.loopState.isBreak || ctx.loopState.isContinue;
+            }
+            else if (ctx.type === context_1.ContextType.Function) {
+                isEOL = () => ctx.functionState.isReturn;
+            }
+            ctx.set(new string_1.default('locals'), ctx.locals.scope);
+            if (ctx.previous && ctx.previous.type !== context_1.ContextType.Api) {
+                ctx.set(new string_1.default('outer'), ctx.previous.locals.scope);
+            }
+            for (let index = 0; index < this.stack.length; index++) {
+                if (isEOL() || ctx.isExit()) {
+                    break;
+                }
+                const op = this.stack[index];
+                yield ctx.step(op);
+                yield op.handle(ctx);
+            }
+            return default_1.default.Void;
+        });
+    }
+}
+exports.default = Block;

package/dist/operations/break.d.ts

@@ -1,10 +1,10 @@
-import { ASTBase } from 'greyscript-core';
-import OperationContext from '../context';
-import CustomValue from '../types/base';
-import Operation, { CPSVisit } from './operation';
-export default class Break extends Operation {
-    readonly item: ASTBase;
-    constructor(item: ASTBase, target?: string);
-    build(_visit: CPSVisit): Promise<Break>;
-    handle(ctx: OperationContext): Promise<CustomValue>;
-}
+import { ASTBase } from 'greyscript-core';
+import OperationContext from '../context';
+import CustomValue from '../types/base';
+import Operation, { CPSVisit } from './operation';
+export default class Break extends Operation {
+    readonly item: ASTBase;
+    constructor(item: ASTBase, target?: string);
+    build(_visit: CPSVisit): Promise<Break>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/break.js

@@ -1,23 +1,23 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const default_1 = __importDefault(require("../types/default"));
-const operation_1 = __importDefault(require("./operation"));
-class Break extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    build(_visit) {
-        return Promise.resolve(this);
-    }
-    handle(ctx) {
-        if (ctx.loopState !== null) {
-            ctx.loopState.isBreak = true;
-        }
-        return Promise.resolve(default_1.default.Void);
-    }
-}
-exports.default = Break;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = __importDefault(require("../types/default"));
+const operation_1 = __importDefault(require("./operation"));
+class Break extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        if (ctx.loopState !== null) {
+            ctx.loopState.isBreak = true;
+        }
+        return Promise.resolve(default_1.default.Void);
+    }
+}
+exports.default = Break;

package/dist/operations/call.d.ts

@@ -1,13 +1,13 @@
-import { ASTCallExpression } from 'greyscript-core';
-import OperationContext from '../context';
-import CustomValue from '../types/base';
-import Operation, { CPSVisit } from './operation';
-import Resolve from './resolve';
-export default class Call extends Operation {
-    readonly item: ASTCallExpression;
-    fnRef: Resolve;
-    args: Array<Operation>;
-    constructor(item: ASTCallExpression, target?: string);
-    build(visit: CPSVisit): Promise<Call>;
-    handle(ctx: OperationContext): Promise<CustomValue>;
-}
+import { ASTCallExpression } from 'greyscript-core';
+import OperationContext from '../context';
+import CustomValue from '../types/base';
+import Operation, { CPSVisit } from './operation';
+import Resolve from './resolve';
+export default class Call extends Operation {
+    readonly item: ASTCallExpression;
+    fnRef: Resolve;
+    args: Array<Operation>;
+    constructor(item: ASTCallExpression, target?: string);
+    build(visit: CPSVisit): Promise<Call>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/call.js

@@ -1,49 +1,49 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const default_1 = __importDefault(require("../types/default"));
-const function_1 = __importDefault(require("../types/function"));
-const operation_1 = __importDefault(require("./operation"));
-const resolve_1 = __importDefault(require("./resolve"));
-class Call extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    build(visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.fnRef = new resolve_1.default(this.item.base);
-            yield this.fnRef.build(visit);
-            const args = this.item.arguments.map((arg) => visit(arg));
-            this.args = yield Promise.all(args);
-            return this;
-        });
-    }
-    handle(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const resolveResult = yield this.fnRef.getResult(ctx);
-            const valueRef = yield this.fnRef.handle(ctx, resolveResult, false);
-            const fnArgs = [];
-            for (let index = 0; index < this.args.length; index++) {
-                fnArgs.push(yield this.args[index].handle(ctx));
-            }
-            if (valueRef instanceof function_1.default) {
-                const func = valueRef;
-                return func.run(resolveResult.handle, fnArgs, ctx);
-            }
-            return default_1.default.Void;
-        });
-    }
-}
-exports.default = Call;
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = __importDefault(require("../types/default"));
+const function_1 = __importDefault(require("../types/function"));
+const operation_1 = __importDefault(require("./operation"));
+const resolve_1 = __importDefault(require("./resolve"));
+class Call extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fnRef = new resolve_1.default(this.item.base);
+            yield this.fnRef.build(visit);
+            const args = this.item.arguments.map((arg) => visit(arg));
+            this.args = yield Promise.all(args);
+            return this;
+        });
+    }
+    handle(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolveResult = yield this.fnRef.getResult(ctx);
+            const valueRef = yield this.fnRef.handle(ctx, resolveResult, false);
+            const fnArgs = [];
+            for (let index = 0; index < this.args.length; index++) {
+                fnArgs.push(yield this.args[index].handle(ctx));
+            }
+            if (valueRef instanceof function_1.default) {
+                const func = valueRef;
+                return func.run(resolveResult.handle, fnArgs, ctx);
+            }
+            return default_1.default.Void;
+        });
+    }
+}
+exports.default = Call;

package/dist/operations/chunk.d.ts

@@ -1,12 +1,12 @@
-import { ASTChunk } from 'greyscript-core';
-import context from '../context';
-import CustomValue from '../types/base';
-import Block from './block';
-import Operation, { CPSVisit } from './operation';
-export default class Chunk extends Operation {
-    readonly item: ASTChunk;
-    block: Block;
-    constructor(item: ASTChunk, target?: string);
-    build(visit: CPSVisit): Promise<Operation>;
-    handle(ctx: context): Promise<CustomValue>;
-}
+import { ASTChunk } from 'greyscript-core';
+import context from '../context';
+import CustomValue from '../types/base';
+import Block from './block';
+import Operation, { CPSVisit } from './operation';
+export default class Chunk extends Operation {
+    readonly item: ASTChunk;
+    block: Block;
+    constructor(item: ASTChunk, target?: string);
+    build(visit: CPSVisit): Promise<Operation>;
+    handle(ctx: context): Promise<CustomValue>;
+}

package/dist/operations/chunk.js

@@ -1,33 +1,33 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const block_1 = __importDefault(require("./block"));
-const operation_1 = __importDefault(require("./operation"));
-class Chunk extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    build(visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stack = yield Promise.all(this.item.body.map((child) => visit(child)));
-            this.block = new block_1.default(stack);
-            return this;
-        });
-    }
-    handle(ctx) {
-        return this.block.handle(ctx);
-    }
-}
-exports.default = Chunk;
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const block_1 = __importDefault(require("./block"));
+const operation_1 = __importDefault(require("./operation"));
+class Chunk extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stack = yield Promise.all(this.item.body.map((child) => visit(child)));
+            this.block = new block_1.default(stack);
+            return this;
+        });
+    }
+    handle(ctx) {
+        return this.block.handle(ctx);
+    }
+}
+exports.default = Chunk;

package/dist/operations/continue.d.ts

@@ -1,10 +1,10 @@
-import { ASTBase } from 'greyscript-core';
-import OperationContext from '../context';
-import CustomValue from '../types/base';
-import Operation, { CPSVisit } from './operation';
-export default class Continue extends Operation {
-    readonly item: ASTBase;
-    constructor(item: ASTBase, target?: string);
-    build(_visit: CPSVisit): Promise<Continue>;
-    handle(ctx: OperationContext): Promise<CustomValue>;
-}
+import { ASTBase } from 'greyscript-core';
+import OperationContext from '../context';
+import CustomValue from '../types/base';
+import Operation, { CPSVisit } from './operation';
+export default class Continue extends Operation {
+    readonly item: ASTBase;
+    constructor(item: ASTBase, target?: string);
+    build(_visit: CPSVisit): Promise<Continue>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/continue.js

@@ -1,23 +1,23 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const default_1 = __importDefault(require("../types/default"));
-const operation_1 = __importDefault(require("./operation"));
-class Continue extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    build(_visit) {
-        return Promise.resolve(this);
-    }
-    handle(ctx) {
-        if (ctx.loopState !== null) {
-            ctx.loopState.isContinue = true;
-        }
-        return Promise.resolve(default_1.default.Void);
-    }
-}
-exports.default = Continue;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = __importDefault(require("../types/default"));
+const operation_1 = __importDefault(require("./operation"));
+class Continue extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        if (ctx.loopState !== null) {
+            ctx.loopState.isContinue = true;
+        }
+        return Promise.resolve(default_1.default.Void);
+    }
+}
+exports.default = Continue;

package/dist/operations/debugger-statement.d.ts

@@ -1,10 +1,10 @@
-import { ASTBase } from 'greyscript-core';
-import context from '../context';
-import CustomValue from '../types/base';
-import Operation, { CPSVisit } from './operation';
-export default class DebuggerStatement extends Operation {
-    readonly item: ASTBase;
-    constructor(item: ASTBase, target?: string);
-    build(_visit: CPSVisit): Promise<DebuggerStatement>;
-    handle(ctx: context): Promise<CustomValue>;
-}
+import { ASTBase } from 'greyscript-core';
+import context from '../context';
+import CustomValue from '../types/base';
+import Operation, { CPSVisit } from './operation';
+export default class DebuggerStatement extends Operation {
+    readonly item: ASTBase;
+    constructor(item: ASTBase, target?: string);
+    build(_visit: CPSVisit): Promise<DebuggerStatement>;
+    handle(ctx: context): Promise<CustomValue>;
+}

package/dist/operations/debugger-statement.js

@@ -1,21 +1,21 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const default_1 = __importDefault(require("../types/default"));
-const operation_1 = __importDefault(require("./operation"));
-class DebuggerStatement extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    build(_visit) {
-        return Promise.resolve(this);
-    }
-    handle(ctx) {
-        ctx.debugger.setBreakpoint(true);
-        return Promise.resolve(default_1.default.Void);
-    }
-}
-exports.default = DebuggerStatement;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = __importDefault(require("../types/default"));
+const operation_1 = __importDefault(require("./operation"));
+class DebuggerStatement extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        ctx.debugger.setBreakpoint(true);
+        return Promise.resolve(default_1.default.Void);
+    }
+}
+exports.default = DebuggerStatement;

package/dist/operations/evaluate.d.ts

@@ -1,40 +1,40 @@
-import { ASTEvaluationExpression } from 'greyscript-core';
-import OperationContext from '../context';
-import CustomValue from '../types/base';
-import Operation, { CPSVisit } from './operation';
-export interface ProcessorHandlerFunction {
-    (op: string, a: CustomValue, b: CustomValue): CustomValue;
-}
-export interface ProcessorHandler {
-    [op: string]: (a: CustomValue, b: CustomValue) => CustomValue;
-}
-export declare const GenericProcessorHandler: ProcessorHandler;
-export declare const NumberProcessorHandler: ProcessorHandler;
-export declare const multiplyString: (a: CustomValue, b: CustomValue) => CustomValue;
-export declare const StringProcessorHandler: ProcessorHandler;
-export declare const ListProcessorHandler: ProcessorHandler;
-export declare const MapProcessorHandler: ProcessorHandler;
-export declare const InterfaceProcessorHandler: ProcessorHandler;
-export declare const NilProcessorHandler: ProcessorHandler;
-export declare const FunctionProcessorHandler: ProcessorHandler;
-export declare const handleNumber: ProcessorHandlerFunction;
-export declare const handleString: ProcessorHandlerFunction;
-export declare const handleList: ProcessorHandlerFunction;
-export declare const handleMap: ProcessorHandlerFunction;
-export declare const handleInterface: ProcessorHandlerFunction;
-export declare const handleNil: ProcessorHandlerFunction;
-export declare const handleFunction: ProcessorHandlerFunction;
-export declare const handle: (op: string, a: CustomValue, b: CustomValue) => CustomValue;
-export default class Evaluate extends Operation {
-    readonly item: ASTEvaluationExpression;
-    type: string;
-    op: string;
-    left: Operation;
-    right: Operation;
-    constructor(item: ASTEvaluationExpression, target?: string);
-    build(visit: CPSVisit): Promise<Operation>;
-    resolveBinaryExpression(ctx: OperationContext, expr: Evaluate): Promise<CustomValue>;
-    resolveLogicalExpression(ctx: OperationContext, expr: Evaluate): Promise<CustomValue>;
-    resolve(ctx: OperationContext, op: Operation): Promise<CustomValue>;
-    handle(ctx: OperationContext): Promise<CustomValue>;
-}
+import { ASTEvaluationExpression } from 'greyscript-core';
+import OperationContext from '../context';
+import CustomValue from '../types/base';
+import Operation, { CPSVisit } from './operation';
+export interface ProcessorHandlerFunction {
+    (op: string, a: CustomValue, b: CustomValue): CustomValue;
+}
+export interface ProcessorHandler {
+    [op: string]: (a: CustomValue, b: CustomValue) => CustomValue;
+}
+export declare const GenericProcessorHandler: ProcessorHandler;
+export declare const NumberProcessorHandler: ProcessorHandler;
+export declare const multiplyString: (a: CustomValue, b: CustomValue) => CustomValue;
+export declare const StringProcessorHandler: ProcessorHandler;
+export declare const ListProcessorHandler: ProcessorHandler;
+export declare const MapProcessorHandler: ProcessorHandler;
+export declare const InterfaceProcessorHandler: ProcessorHandler;
+export declare const NilProcessorHandler: ProcessorHandler;
+export declare const FunctionProcessorHandler: ProcessorHandler;
+export declare const handleNumber: ProcessorHandlerFunction;
+export declare const handleString: ProcessorHandlerFunction;
+export declare const handleList: ProcessorHandlerFunction;
+export declare const handleMap: ProcessorHandlerFunction;
+export declare const handleInterface: ProcessorHandlerFunction;
+export declare const handleNil: ProcessorHandlerFunction;
+export declare const handleFunction: ProcessorHandlerFunction;
+export declare const handle: (op: string, a: CustomValue, b: CustomValue) => CustomValue;
+export default class Evaluate extends Operation {
+    readonly item: ASTEvaluationExpression;
+    type: string;
+    op: string;
+    left: Operation;
+    right: Operation;
+    constructor(item: ASTEvaluationExpression, target?: string);
+    build(visit: CPSVisit): Promise<Operation>;
+    resolveBinaryExpression(ctx: OperationContext, expr: Evaluate): Promise<CustomValue>;
+    resolveLogicalExpression(ctx: OperationContext, expr: Evaluate): Promise<CustomValue>;
+    resolve(ctx: OperationContext, op: Operation): Promise<CustomValue>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}