greybel-interpreter 1.4.6 → 1.4.7

package/dist/operations/resolve.d.ts

@@ -1,38 +1,38 @@
-import { ASTBase } from 'greyscript-core';
-import OperationContext from '../context';
-import CustomValue from '../types/base';
-import Path from '../utils/path';
-import Operation, { CPSVisit } from './operation';
-export declare class SliceSegment {
-    readonly left: Operation;
-    readonly right: Operation;
-    constructor(left: Operation, right: Operation);
-}
-export declare class IdentifierSegment {
-    readonly value: string;
-    constructor(value: string);
-}
-export declare class IndexSegment {
-    readonly op: Operation;
-    constructor(op: Operation);
-}
-export declare class OperationSegment {
-    readonly op: Operation;
-    constructor(op: Operation);
-}
-export declare type Segment = SliceSegment | IdentifierSegment | IndexSegment | OperationSegment;
-export declare class ResolveResult {
-    readonly path: Path<CustomValue>;
-    readonly handle: CustomValue;
-    constructor(path: Path<CustomValue>, handle: CustomValue);
-}
-export default class Resolve extends Operation {
-    readonly item: ASTBase;
-    path: Array<Segment>;
-    last: Segment;
-    constructor(item: ASTBase, target?: string);
-    buildProcessor(node: ASTBase, visit: CPSVisit): Promise<void>;
-    build(visit: CPSVisit): Promise<Resolve>;
-    getResult(ctx: OperationContext): Promise<ResolveResult>;
-    handle(ctx: OperationContext, result?: ResolveResult, autoCall?: boolean): Promise<CustomValue>;
-}
+import { ASTBase } from 'greyscript-core';
+import OperationContext from '../context';
+import CustomValue from '../types/base';
+import Path from '../utils/path';
+import Operation, { CPSVisit } from './operation';
+export declare class SliceSegment {
+    readonly left: Operation;
+    readonly right: Operation;
+    constructor(left: Operation, right: Operation);
+}
+export declare class IdentifierSegment {
+    readonly value: string;
+    constructor(value: string);
+}
+export declare class IndexSegment {
+    readonly op: Operation;
+    constructor(op: Operation);
+}
+export declare class OperationSegment {
+    readonly op: Operation;
+    constructor(op: Operation);
+}
+export declare type Segment = SliceSegment | IdentifierSegment | IndexSegment | OperationSegment;
+export declare class ResolveResult {
+    readonly path: Path<CustomValue>;
+    readonly handle: CustomValue;
+    constructor(path: Path<CustomValue>, handle: CustomValue);
+}
+export default class Resolve extends Operation {
+    readonly item: ASTBase;
+    path: Array<Segment>;
+    last: Segment;
+    constructor(item: ASTBase, target?: string);
+    buildProcessor(node: ASTBase, visit: CPSVisit): Promise<void>;
+    build(visit: CPSVisit): Promise<Resolve>;
+    getResult(ctx: OperationContext): Promise<ResolveResult>;
+    handle(ctx: OperationContext, result?: ResolveResult, autoCall?: boolean): Promise<CustomValue>;
+}

package/dist/operations/resolve.js

@@ -1,210 +1,210 @@
-"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.ResolveResult = exports.OperationSegment = exports.IndexSegment = exports.IdentifierSegment = exports.SliceSegment = void 0;
-const greyscript_core_1 = require("greyscript-core");
-const default_1 = __importDefault(require("../types/default"));
-const function_1 = __importDefault(require("../types/function"));
-const list_1 = __importDefault(require("../types/list"));
-const string_1 = __importDefault(require("../types/string"));
-const with_intrinsics_1 = require("../types/with-intrinsics");
-const path_1 = __importDefault(require("../utils/path"));
-const operation_1 = __importDefault(require("./operation"));
-class SliceSegment {
-    constructor(left, right) {
-        this.left = left;
-        this.right = right;
-    }
-}
-exports.SliceSegment = SliceSegment;
-class IdentifierSegment {
-    constructor(value) {
-        this.value = value;
-    }
-}
-exports.IdentifierSegment = IdentifierSegment;
-class IndexSegment {
-    constructor(op) {
-        this.op = op;
-    }
-}
-exports.IndexSegment = IndexSegment;
-class OperationSegment {
-    constructor(op) {
-        this.op = op;
-    }
-}
-exports.OperationSegment = OperationSegment;
-class ResolveResult {
-    constructor(path, handle) {
-        this.path = path;
-        this.handle = handle;
-    }
-}
-exports.ResolveResult = ResolveResult;
-class Resolve extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    buildProcessor(node, visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (node.type) {
-                case greyscript_core_1.ASTType.MemberExpression: {
-                    const memberExpr = node;
-                    yield this.buildProcessor(memberExpr.base, visit);
-                    yield this.buildProcessor(memberExpr.identifier, visit);
-                    break;
-                }
-                case greyscript_core_1.ASTType.IndexExpression: {
-                    const indexExpr = node;
-                    yield this.buildProcessor(indexExpr.base, visit);
-                    if (indexExpr.index.type === greyscript_core_1.ASTType.SliceExpression) {
-                        const sliceExpr = indexExpr.index;
-                        const left = yield visit(sliceExpr.left);
-                        const right = yield visit(sliceExpr.right);
-                        const sliceSegment = new SliceSegment(left, right);
-                        this.path.push(sliceSegment);
-                    }
-                    else {
-                        const indexSegment = new IndexSegment(yield visit(indexExpr.index));
-                        this.path.push(indexSegment);
-                    }
-                    break;
-                }
-                case greyscript_core_1.ASTType.Identifier: {
-                    const identifier = node;
-                    const identifierSegment = new IdentifierSegment(identifier.name);
-                    this.path.push(identifierSegment);
-                    break;
-                }
-                default: {
-                    const opSegment = new OperationSegment(yield visit(node));
-                    this.path.push(opSegment);
-                    break;
-                }
-            }
-        });
-    }
-    build(visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.path = [];
-            yield this.buildProcessor(this.item, visit);
-            this.last = this.path[this.path.length - 1];
-            return this;
-        });
-    }
-    getResult(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let traversedPath = new path_1.default();
-            let handle = default_1.default.Void;
-            const maxIndex = this.path.length;
-            const lastIndex = maxIndex - 1;
-            for (let index = 0; index < maxIndex; index++) {
-                const current = this.path[index];
-                if (current instanceof OperationSegment) {
-                    const opSegment = current;
-                    handle = yield opSegment.op.handle(ctx);
-                }
-                else if (current instanceof IdentifierSegment) {
-                    const identifierSegment = current;
-                    traversedPath.add(new string_1.default(identifierSegment.value));
-                    if (index === lastIndex) {
-                        break;
-                    }
-                    const previous = handle;
-                    if (handle !== default_1.default.Void) {
-                        if (handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
-                            const customValueCtx = handle;
-                            handle = customValueCtx.get(traversedPath);
-                        }
-                        else {
-                            throw new Error('Handle has no properties.');
-                        }
-                    }
-                    else {
-                        handle = ctx.get(traversedPath);
-                    }
-                    if (handle instanceof function_1.default) {
-                        handle = yield handle.run(previous || default_1.default.Void, [], ctx);
-                    }
-                    traversedPath = new path_1.default();
-                }
-                else if (current instanceof IndexSegment) {
-                    const indexSegment = current;
-                    const indexValue = yield indexSegment.op.handle(ctx);
-                    traversedPath.add(indexValue);
-                    if (index === lastIndex) {
-                        break;
-                    }
-                    if (handle !== default_1.default.Void) {
-                        if (handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
-                            const customValueCtx = handle;
-                            handle = customValueCtx.get(traversedPath);
-                        }
-                        else {
-                            throw new Error('Handle has no properties.');
-                        }
-                    }
-                    else {
-                        handle = ctx.get(traversedPath);
-                    }
-                    traversedPath = new path_1.default();
-                }
-                else if (current instanceof SliceSegment) {
-                    const sliceSegment = current;
-                    const left = yield sliceSegment.left.handle(ctx);
-                    const right = yield sliceSegment.right.handle(ctx);
-                    if (handle instanceof list_1.default || handle instanceof string_1.default) {
-                        handle = handle.slice(left, right);
-                    }
-                    else {
-                        throw new Error(`Unexpected slice attempt. ${handle.getCustomType()} does not seem to support slicing.`);
-                    }
-                }
-            }
-            return new ResolveResult(traversedPath, handle);
-        });
-    }
-    handle(ctx, result = null, autoCall = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (result === null) {
-                result = yield this.getResult(ctx);
-            }
-            if (result.handle !== default_1.default.Void) {
-                if (result.path.count() === 0) {
-                    if (autoCall && result.handle instanceof function_1.default) {
-                        return result.handle.run(default_1.default.Void, [], ctx);
-                    }
-                    return result.handle;
-                }
-                const customValueCtx = result.handle;
-                const child = customValueCtx.get(result.path);
-                if (autoCall &&
-                    child instanceof function_1.default &&
-                    // support index bug in greyscript
-                    !(this.last instanceof IndexSegment)) {
-                    return child.run(customValueCtx, [], ctx);
-                }
-                return child;
-            }
-            const handle = ctx.get(result.path);
-            if (autoCall && handle instanceof function_1.default) {
-                return handle.run(default_1.default.Void, [], ctx);
-            }
-            return handle;
-        });
-    }
-}
-exports.default = Resolve;
+"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.ResolveResult = exports.OperationSegment = exports.IndexSegment = exports.IdentifierSegment = exports.SliceSegment = void 0;
+const greyscript_core_1 = require("greyscript-core");
+const default_1 = __importDefault(require("../types/default"));
+const function_1 = __importDefault(require("../types/function"));
+const list_1 = __importDefault(require("../types/list"));
+const string_1 = __importDefault(require("../types/string"));
+const with_intrinsics_1 = require("../types/with-intrinsics");
+const path_1 = __importDefault(require("../utils/path"));
+const operation_1 = __importDefault(require("./operation"));
+class SliceSegment {
+    constructor(left, right) {
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.SliceSegment = SliceSegment;
+class IdentifierSegment {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.IdentifierSegment = IdentifierSegment;
+class IndexSegment {
+    constructor(op) {
+        this.op = op;
+    }
+}
+exports.IndexSegment = IndexSegment;
+class OperationSegment {
+    constructor(op) {
+        this.op = op;
+    }
+}
+exports.OperationSegment = OperationSegment;
+class ResolveResult {
+    constructor(path, handle) {
+        this.path = path;
+        this.handle = handle;
+    }
+}
+exports.ResolveResult = ResolveResult;
+class Resolve extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    buildProcessor(node, visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (node.type) {
+                case greyscript_core_1.ASTType.MemberExpression: {
+                    const memberExpr = node;
+                    yield this.buildProcessor(memberExpr.base, visit);
+                    yield this.buildProcessor(memberExpr.identifier, visit);
+                    break;
+                }
+                case greyscript_core_1.ASTType.IndexExpression: {
+                    const indexExpr = node;
+                    yield this.buildProcessor(indexExpr.base, visit);
+                    if (indexExpr.index.type === greyscript_core_1.ASTType.SliceExpression) {
+                        const sliceExpr = indexExpr.index;
+                        const left = yield visit(sliceExpr.left);
+                        const right = yield visit(sliceExpr.right);
+                        const sliceSegment = new SliceSegment(left, right);
+                        this.path.push(sliceSegment);
+                    }
+                    else {
+                        const indexSegment = new IndexSegment(yield visit(indexExpr.index));
+                        this.path.push(indexSegment);
+                    }
+                    break;
+                }
+                case greyscript_core_1.ASTType.Identifier: {
+                    const identifier = node;
+                    const identifierSegment = new IdentifierSegment(identifier.name);
+                    this.path.push(identifierSegment);
+                    break;
+                }
+                default: {
+                    const opSegment = new OperationSegment(yield visit(node));
+                    this.path.push(opSegment);
+                    break;
+                }
+            }
+        });
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.path = [];
+            yield this.buildProcessor(this.item, visit);
+            this.last = this.path[this.path.length - 1];
+            return this;
+        });
+    }
+    getResult(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let traversedPath = new path_1.default();
+            let handle = default_1.default.Void;
+            const maxIndex = this.path.length;
+            const lastIndex = maxIndex - 1;
+            for (let index = 0; index < maxIndex; index++) {
+                const current = this.path[index];
+                if (current instanceof OperationSegment) {
+                    const opSegment = current;
+                    handle = yield opSegment.op.handle(ctx);
+                }
+                else if (current instanceof IdentifierSegment) {
+                    const identifierSegment = current;
+                    traversedPath.add(new string_1.default(identifierSegment.value));
+                    if (index === lastIndex) {
+                        break;
+                    }
+                    const previous = handle;
+                    if (handle !== default_1.default.Void) {
+                        if (handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
+                            const customValueCtx = handle;
+                            handle = customValueCtx.get(traversedPath);
+                        }
+                        else {
+                            throw new Error('Handle has no properties.');
+                        }
+                    }
+                    else {
+                        handle = ctx.get(traversedPath);
+                    }
+                    if (handle instanceof function_1.default) {
+                        handle = yield handle.run(previous || default_1.default.Void, [], ctx);
+                    }
+                    traversedPath = new path_1.default();
+                }
+                else if (current instanceof IndexSegment) {
+                    const indexSegment = current;
+                    const indexValue = yield indexSegment.op.handle(ctx);
+                    traversedPath.add(indexValue);
+                    if (index === lastIndex) {
+                        break;
+                    }
+                    if (handle !== default_1.default.Void) {
+                        if (handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
+                            const customValueCtx = handle;
+                            handle = customValueCtx.get(traversedPath);
+                        }
+                        else {
+                            throw new Error('Handle has no properties.');
+                        }
+                    }
+                    else {
+                        handle = ctx.get(traversedPath);
+                    }
+                    traversedPath = new path_1.default();
+                }
+                else if (current instanceof SliceSegment) {
+                    const sliceSegment = current;
+                    const left = yield sliceSegment.left.handle(ctx);
+                    const right = yield sliceSegment.right.handle(ctx);
+                    if (handle instanceof list_1.default || handle instanceof string_1.default) {
+                        handle = handle.slice(left, right);
+                    }
+                    else {
+                        throw new Error(`Unexpected slice attempt. ${handle.getCustomType()} does not seem to support slicing.`);
+                    }
+                }
+            }
+            return new ResolveResult(traversedPath, handle);
+        });
+    }
+    handle(ctx, result = null, autoCall = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (result === null) {
+                result = yield this.getResult(ctx);
+            }
+            if (result.handle !== default_1.default.Void) {
+                if (result.path.count() === 0) {
+                    if (autoCall && result.handle instanceof function_1.default) {
+                        return result.handle.run(default_1.default.Void, [], ctx);
+                    }
+                    return result.handle;
+                }
+                const customValueCtx = result.handle;
+                const child = customValueCtx.get(result.path);
+                if (autoCall &&
+                    child instanceof function_1.default &&
+                    // support index bug in greyscript
+                    !(this.last instanceof IndexSegment)) {
+                    return child.run(customValueCtx, [], ctx);
+                }
+                return child;
+            }
+            const handle = ctx.get(result.path);
+            if (autoCall && handle instanceof function_1.default) {
+                return handle.run(default_1.default.Void, [], ctx);
+            }
+            return handle;
+        });
+    }
+}
+exports.default = Resolve;

package/dist/operations/return.d.ts

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

package/dist/operations/return.js

@@ -1,45 +1,45 @@
-"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 reference_1 = __importDefault(require("./reference"));
-class Return extends operation_1.default {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    build(visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.item.argument) {
-                this.arg = yield visit(this.item.argument);
-            }
-            else {
-                this.arg = new reference_1.default(default_1.default.Void);
-            }
-            return this;
-        });
-    }
-    handle(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // no typesafe equal
-            if (ctx.functionState != null) {
-                ctx.functionState.value = yield this.arg.handle(ctx);
-                ctx.functionState.isReturn = true;
-            }
-            return default_1.default.Void;
-        });
-    }
-}
-exports.default = Return;
+"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 reference_1 = __importDefault(require("./reference"));
+class Return extends operation_1.default {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.item.argument) {
+                this.arg = yield visit(this.item.argument);
+            }
+            else {
+                this.arg = new reference_1.default(default_1.default.Void);
+            }
+            return this;
+        });
+    }
+    handle(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // no typesafe equal
+            if (ctx.functionState != null) {
+                ctx.functionState.value = yield this.arg.handle(ctx);
+                ctx.functionState.isReturn = true;
+            }
+            return default_1.default.Void;
+        });
+    }
+}
+exports.default = Return;

package/dist/operations/while.d.ts

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