greybel-interpreter 1.4.6 → 1.4.8

package/dist/operations/for.d.ts

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

package/dist/operations/for.js

@@ -1,81 +1,81 @@
-"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 number_1 = __importDefault(require("../types/number"));
-const string_1 = __importDefault(require("../types/string"));
-const block_1 = __importDefault(require("./block"));
-const operation_1 = __importDefault(require("./operation"));
-class For 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);
-            this.variable = this.item.variable;
-            this.iterator = yield visit(this.item.iterator);
-            return this;
-        });
-    }
-    handle(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const forCtx = ctx.fork({
-                type: context_1.ContextType.Loop,
-                state: context_1.ContextState.Temporary
-            });
-            const identifier = this.variable.name;
-            const iteratorValue = (yield this.iterator.handle(ctx));
-            if (typeof iteratorValue[Symbol.iterator] !== 'function') {
-                return Promise.resolve(default_1.default.Void);
-            }
-            const loopState = new context_1.LoopState();
-            let index = 0;
-            forCtx.loopState = loopState;
-            return new Promise((resolve, reject) => {
-                const iterator = iteratorValue[Symbol.iterator]();
-                const idxIdentifier = new string_1.default(`__${identifier}_idx`);
-                const varIdentifier = new string_1.default(identifier);
-                let iteratorResult = iterator.next();
-                const iteration = () => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        if (iteratorResult.done) {
-                            resolve(default_1.default.Void);
-                            return;
-                        }
-                        const current = iteratorResult.value;
-                        loopState.isContinue = false;
-                        forCtx.set(idxIdentifier, new number_1.default(index++));
-                        forCtx.set(varIdentifier, current);
-                        yield this.block.handle(forCtx);
-                        if (loopState.isBreak || ctx.isExit()) {
-                            resolve(default_1.default.Void);
-                            return;
-                        }
-                        iteratorResult = iterator.next();
-                        process.nextTick(iteration);
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                });
-                iteration();
-            });
-        });
-    }
-}
-exports.default = For;
+"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 number_1 = __importDefault(require("../types/number"));
+const string_1 = __importDefault(require("../types/string"));
+const block_1 = __importDefault(require("./block"));
+const operation_1 = __importDefault(require("./operation"));
+class For 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);
+            this.variable = this.item.variable;
+            this.iterator = yield visit(this.item.iterator);
+            return this;
+        });
+    }
+    handle(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const forCtx = ctx.fork({
+                type: context_1.ContextType.Loop,
+                state: context_1.ContextState.Temporary
+            });
+            const identifier = this.variable.name;
+            const iteratorValue = (yield this.iterator.handle(ctx));
+            if (typeof iteratorValue[Symbol.iterator] !== 'function') {
+                return Promise.resolve(default_1.default.Void);
+            }
+            const loopState = new context_1.LoopState();
+            let index = 0;
+            forCtx.loopState = loopState;
+            return new Promise((resolve, reject) => {
+                const iterator = iteratorValue[Symbol.iterator]();
+                const idxIdentifier = new string_1.default(`__${identifier}_idx`);
+                const varIdentifier = new string_1.default(identifier);
+                let iteratorResult = iterator.next();
+                const iteration = () => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        if (iteratorResult.done) {
+                            resolve(default_1.default.Void);
+                            return;
+                        }
+                        const current = iteratorResult.value;
+                        loopState.isContinue = false;
+                        forCtx.set(idxIdentifier, new number_1.default(index++));
+                        forCtx.set(varIdentifier, current);
+                        yield this.block.handle(forCtx);
+                        if (loopState.isBreak || ctx.isExit()) {
+                            resolve(default_1.default.Void);
+                            return;
+                        }
+                        iteratorResult = iterator.next();
+                        process.nextTick(iteration);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+                iteration();
+            });
+        });
+    }
+}
+exports.default = For;

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

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

package/dist/operations/function-reference.js

@@ -1,44 +1,44 @@
-"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 operation_1 = __importDefault(require("./operation"));
-const resolve_1 = __importDefault(require("./resolve"));
-class FunctionReference extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    build(visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ref = new resolve_1.default(this.item.argument);
-            yield this.ref.build(visit);
-            return this;
-        });
-    }
-    handle(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const refResult = yield this.ref.getResult(ctx);
-            if (refResult.handle !== default_1.default.Void) {
-                if (refResult.path.count() === 0) {
-                    return refResult.handle;
-                }
-                const customValueCtx = refResult.handle;
-                return customValueCtx.get(refResult.path);
-            }
-            return ctx.get(refResult.path);
-        });
-    }
-}
-exports.default = FunctionReference;
+"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 operation_1 = __importDefault(require("./operation"));
+const resolve_1 = __importDefault(require("./resolve"));
+class FunctionReference extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ref = new resolve_1.default(this.item.argument);
+            yield this.ref.build(visit);
+            return this;
+        });
+    }
+    handle(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const refResult = yield this.ref.getResult(ctx);
+            if (refResult.handle !== default_1.default.Void) {
+                if (refResult.path.count() === 0) {
+                    return refResult.handle;
+                }
+                const customValueCtx = refResult.handle;
+                return customValueCtx.get(refResult.path);
+            }
+            return ctx.get(refResult.path);
+        });
+    }
+}
+exports.default = FunctionReference;

package/dist/operations/function.d.ts

@@ -1,14 +1,14 @@
-import { ASTFunctionStatement } from 'greyscript-core';
-import OperationContext from '../context';
-import CustomValue from '../types/base';
-import CustomString from '../types/string';
-import Operation, { CPSVisit } from './operation';
-export declare const SELF_PROPERTY: CustomString;
-export default class FunctionOperation extends Operation {
-    readonly item: ASTFunctionStatement;
-    block: Operation;
-    args: Map<string, Operation>;
-    constructor(item: ASTFunctionStatement, target?: string);
-    build(visit: CPSVisit): Promise<Operation>;
-    handle(ctx: OperationContext): Promise<CustomValue>;
-}
+import { ASTFunctionStatement } from 'greyscript-core';
+import OperationContext from '../context';
+import CustomValue from '../types/base';
+import CustomString from '../types/string';
+import Operation, { CPSVisit } from './operation';
+export declare const SELF_PROPERTY: CustomString;
+export default class FunctionOperation extends Operation {
+    readonly item: ASTFunctionStatement;
+    block: Operation;
+    args: Map<string, Operation>;
+    constructor(item: ASTFunctionStatement, target?: string);
+    build(visit: CPSVisit): Promise<Operation>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/function.js

@@ -1,72 +1,72 @@
-"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 });
-exports.SELF_PROPERTY = void 0;
-const greyscript_core_1 = require("greyscript-core");
-const context_1 = require("../context");
-const default_1 = __importDefault(require("../types/default"));
-const function_1 = __importDefault(require("../types/function"));
-const string_1 = __importDefault(require("../types/string"));
-const block_1 = __importDefault(require("./block"));
-const operation_1 = __importDefault(require("./operation"));
-const reference_1 = __importDefault(require("./reference"));
-exports.SELF_PROPERTY = new string_1.default('self');
-class FunctionOperation 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);
-            this.args = new Map();
-            const defers = this.item.parameters.map((child) => __awaiter(this, void 0, void 0, function* () {
-                switch (child.type) {
-                    case greyscript_core_1.ASTType.AssignmentStatement: {
-                        const assignStatement = child;
-                        const assignKey = assignStatement.variable;
-                        this.args.set(assignKey.name, yield visit(assignStatement.init));
-                        break;
-                    }
-                    case greyscript_core_1.ASTType.Identifier: {
-                        const identifierKey = child;
-                        this.args.set(identifierKey.name, new reference_1.default(default_1.default.Void));
-                        break;
-                    }
-                    default:
-                        throw new Error('Unexpected operation in arguments.');
-                }
-            }));
-            yield Promise.all(defers);
-            return this;
-        });
-    }
-    handle(ctx) {
-        const func = new function_1.default(ctx, 'anonymous', (fnCtx, self, args) => __awaiter(this, void 0, void 0, function* () {
-            fnCtx.functionState = new context_1.FunctionState();
-            fnCtx.set(exports.SELF_PROPERTY, self);
-            for (const [key, value] of args) {
-                fnCtx.set(new string_1.default(key), value);
-            }
-            yield this.block.handle(fnCtx);
-            return fnCtx.functionState.value;
-        }));
-        for (const [key, value] of this.args) {
-            func.addArgument(key, value);
-        }
-        return Promise.resolve(func);
-    }
-}
-exports.default = FunctionOperation;
+"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 });
+exports.SELF_PROPERTY = void 0;
+const greyscript_core_1 = require("greyscript-core");
+const context_1 = require("../context");
+const default_1 = __importDefault(require("../types/default"));
+const function_1 = __importDefault(require("../types/function"));
+const string_1 = __importDefault(require("../types/string"));
+const block_1 = __importDefault(require("./block"));
+const operation_1 = __importDefault(require("./operation"));
+const reference_1 = __importDefault(require("./reference"));
+exports.SELF_PROPERTY = new string_1.default('self');
+class FunctionOperation 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);
+            this.args = new Map();
+            const defers = this.item.parameters.map((child) => __awaiter(this, void 0, void 0, function* () {
+                switch (child.type) {
+                    case greyscript_core_1.ASTType.AssignmentStatement: {
+                        const assignStatement = child;
+                        const assignKey = assignStatement.variable;
+                        this.args.set(assignKey.name, yield visit(assignStatement.init));
+                        break;
+                    }
+                    case greyscript_core_1.ASTType.Identifier: {
+                        const identifierKey = child;
+                        this.args.set(identifierKey.name, new reference_1.default(default_1.default.Void));
+                        break;
+                    }
+                    default:
+                        throw new Error('Unexpected operation in arguments.');
+                }
+            }));
+            yield Promise.all(defers);
+            return this;
+        });
+    }
+    handle(ctx) {
+        const func = new function_1.default(ctx, 'anonymous', (fnCtx, self, args) => __awaiter(this, void 0, void 0, function* () {
+            fnCtx.functionState = new context_1.FunctionState();
+            fnCtx.set(exports.SELF_PROPERTY, self);
+            for (const [key, value] of args) {
+                fnCtx.set(new string_1.default(key), value);
+            }
+            yield this.block.handle(fnCtx);
+            return fnCtx.functionState.value;
+        }));
+        for (const [key, value] of this.args) {
+            func.addArgument(key, value);
+        }
+        return Promise.resolve(func);
+    }
+}
+exports.default = FunctionOperation;

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

@@ -1,19 +1,19 @@
-import { ASTElseClause, ASTIfClause, ASTIfStatement } from 'greyscript-core';
-import context from '../context';
-import CustomValue from '../types/base';
-import Block from './block';
-import Operation, { CPSVisit } from './operation';
-export declare class Clause {
-    readonly condition: Operation;
-    readonly block: Block;
-    constructor(condition: Operation, block: Block);
-}
-export default class IfStatement extends Operation {
-    readonly item: ASTIfStatement;
-    clauses: Array<Clause>;
-    constructor(item: ASTIfStatement, target?: string);
-    buildIfClause(node: ASTIfClause, visit: CPSVisit): Promise<void>;
-    buildElseClause(node: ASTElseClause, visit: CPSVisit): Promise<void>;
-    build(visit: CPSVisit): Promise<Operation>;
-    handle(ctx: context): Promise<CustomValue>;
-}
+import { ASTElseClause, ASTIfClause, ASTIfStatement } from 'greyscript-core';
+import context from '../context';
+import CustomValue from '../types/base';
+import Block from './block';
+import Operation, { CPSVisit } from './operation';
+export declare class Clause {
+    readonly condition: Operation;
+    readonly block: Block;
+    constructor(condition: Operation, block: Block);
+}
+export default class IfStatement extends Operation {
+    readonly item: ASTIfStatement;
+    clauses: Array<Clause>;
+    constructor(item: ASTIfStatement, target?: string);
+    buildIfClause(node: ASTIfClause, visit: CPSVisit): Promise<void>;
+    buildElseClause(node: ASTElseClause, visit: CPSVisit): Promise<void>;
+    build(visit: CPSVisit): Promise<Operation>;
+    handle(ctx: context): Promise<CustomValue>;
+}