greybel-interpreter 3.5.0 → 4.0.0

package/dist/operations/resolve.js

@@ -1,269 +0,0 @@
-"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.Resolve = exports.ResolveResult = exports.ResolveNil = exports.SegmentContainer = exports.OperationSegment = exports.IndexSegment = exports.IdentifierSegment = exports.PathSegment = exports.SliceSegment = void 0;
-const miniscript_core_1 = require("miniscript-core");
-const default_1 = require("../types/default");
-const function_1 = require("../types/function");
-const list_1 = require("../types/list");
-const map_1 = require("../types/map");
-const nil_1 = require("../types/nil");
-const string_1 = require("../types/string");
-const with_intrinsics_1 = require("../types/with-intrinsics");
-const get_super_1 = require("../utils/get-super");
-const path_1 = require("../utils/path");
-const operation_1 = require("./operation");
-class SliceSegment {
-    constructor(left, right) {
-        this.left = left;
-        this.right = right;
-    }
-}
-exports.SliceSegment = SliceSegment;
-class PathSegment {
-    toPath(_ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return Promise.resolve(default_1.DefaultType.Void);
-        });
-    }
-}
-exports.PathSegment = PathSegment;
-class IdentifierSegment extends PathSegment {
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    toPath(_ctx) {
-        return Promise.resolve(new string_1.CustomString(this.value));
-    }
-}
-exports.IdentifierSegment = IdentifierSegment;
-class IndexSegment extends PathSegment {
-    constructor(op) {
-        super();
-        this.op = op;
-    }
-    toPath(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.op.handle(ctx);
-        });
-    }
-}
-exports.IndexSegment = IndexSegment;
-class OperationSegment {
-    constructor(op) {
-        this.op = op;
-    }
-}
-exports.OperationSegment = OperationSegment;
-class SegmentContainer {
-    constructor() {
-        this.path = [];
-    }
-    push(item) {
-        this.path.push(item);
-        return this;
-    }
-    count() {
-        return this.path.length;
-    }
-    at(index) {
-        return this.path[index];
-    }
-    isSuper() {
-        return (this.path.length === 2 &&
-            this.path[0] instanceof IdentifierSegment &&
-            this.path[0].value === function_1.SUPER_NAMESPACE);
-    }
-    getLast() {
-        return this.path[this.path.length - 1];
-    }
-}
-exports.SegmentContainer = SegmentContainer;
-class ResolveNil extends nil_1.CustomNil {
-}
-exports.ResolveNil = ResolveNil;
-class ResolveResult {
-    constructor(path, handle) {
-        this.path = path;
-        this.handle = handle;
-    }
-}
-exports.ResolveResult = ResolveResult;
-class Resolve extends operation_1.Operation {
-    constructor(item, target) {
-        super(null, target);
-        this.item = item;
-    }
-    buildProcessor(node, visit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (node.type) {
-                case miniscript_core_1.ASTType.MemberExpression: {
-                    const memberExpr = node;
-                    if (memberExpr.base != null)
-                        yield this.buildProcessor(memberExpr.base, visit);
-                    yield this.buildProcessor(memberExpr.identifier, visit);
-                    break;
-                }
-                case miniscript_core_1.ASTType.IndexExpression: {
-                    const indexExpr = node;
-                    if (indexExpr.base != null)
-                        yield this.buildProcessor(indexExpr.base, visit);
-                    const indexSegment = new IndexSegment(yield visit(indexExpr.index));
-                    this.path.push(indexSegment);
-                    break;
-                }
-                case miniscript_core_1.ASTType.SliceExpression: {
-                    const sliceExpr = node;
-                    if (sliceExpr.base != null)
-                        yield this.buildProcessor(sliceExpr.base, visit);
-                    const left = yield visit(sliceExpr.left);
-                    const right = yield visit(sliceExpr.right);
-                    const sliceSegment = new SliceSegment(left, right);
-                    this.path.push(sliceSegment);
-                    break;
-                }
-                case miniscript_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 = new SegmentContainer();
-            yield this.buildProcessor(this.item, visit);
-            this.last = this.path.getLast();
-            return this;
-        });
-    }
-    getResult(ctx, handle = new ResolveNil()) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let traversedPath = new path_1.Path();
-            let index = 0;
-            const exitObserver = ctx.processState.createExitObserver();
-            const maxIndex = this.path.count();
-            const lastIndex = maxIndex - 1;
-            for (; index < maxIndex; index++) {
-                if (exitObserver.occured()) {
-                    exitObserver.close();
-                    return new ResolveResult(null, new ResolveNil());
-                }
-                const current = this.path.at(index);
-                if (current instanceof OperationSegment) {
-                    const opSegment = current;
-                    handle = yield opSegment.op.handle(ctx);
-                }
-                else if (current instanceof PathSegment) {
-                    traversedPath.add(yield current.toPath(ctx));
-                    if (index === lastIndex) {
-                        break;
-                    }
-                    const previous = handle;
-                    if (!(handle instanceof ResolveNil)) {
-                        if (handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
-                            const customValueCtx = handle;
-                            handle = customValueCtx.get(traversedPath, ctx.contextTypeIntrinsics);
-                        }
-                        else {
-                            throw new Error(`Unknown path ${traversedPath.toString()}.`);
-                        }
-                    }
-                    else {
-                        handle = ctx.get(traversedPath);
-                    }
-                    if (handle instanceof function_1.CustomFunction) {
-                        if (index === 1 &&
-                            traversedPath.toString() === function_1.SUPER_NAMESPACE &&
-                            ctx.functionState.context &&
-                            previous instanceof map_1.CustomMap) {
-                            handle.setNextContext(previous.getIsa());
-                            handle = yield handle.run(ctx.functionState.context, [], ctx);
-                        }
-                        else {
-                            handle = yield handle.run(previous || default_1.DefaultType.Void, [], ctx);
-                        }
-                    }
-                    traversedPath = new path_1.Path();
-                }
-                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.CustomList || handle instanceof string_1.CustomString) {
-                        handle = handle.slice(left, right);
-                    }
-                    else {
-                        throw new Error(`Unexpected slice attempt. ${handle.getCustomType()} does not seem to support slicing.`);
-                    }
-                }
-            }
-            exitObserver.close();
-            return new ResolveResult(traversedPath, handle);
-        });
-    }
-    handle(ctx, result = null, autoCall = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (result === null) {
-                const exitObserver = ctx.processState.createExitObserver();
-                result = yield this.getResult(ctx);
-                exitObserver.close();
-                if (exitObserver.occured()) {
-                    return default_1.DefaultType.Void;
-                }
-            }
-            if (!(result.handle instanceof ResolveNil)) {
-                if (result.path.count() === 0) {
-                    if (autoCall && result.handle instanceof function_1.CustomFunction) {
-                        return result.handle.run(default_1.DefaultType.Void, [], ctx);
-                    }
-                    return result.handle;
-                }
-                if (result.handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
-                    const customValueCtx = result.handle;
-                    const { value: child, origin } = customValueCtx.getWithOrigin(result.path, ctx.contextTypeIntrinsics);
-                    const next = (0, get_super_1.getSuper)(origin);
-                    if (child instanceof function_1.CustomFunction) {
-                        child.setNextContext(next);
-                    }
-                    if (this.path.isSuper() && customValueCtx instanceof map_1.CustomMap) {
-                        if (autoCall && child instanceof function_1.CustomFunction) {
-                            if (ctx.functionState.context) {
-                                return child.run(ctx.functionState.context, [], ctx);
-                            }
-                            return child.run(customValueCtx, [], ctx);
-                        }
-                        return child;
-                    }
-                    if (autoCall && child instanceof function_1.CustomFunction) {
-                        return child.run(customValueCtx, [], ctx);
-                    }
-                    return child;
-                }
-                throw new Error(`Unknown path ${result.path.toString()}.`);
-            }
-            const handle = ctx.get(result.path);
-            if (autoCall && handle instanceof function_1.CustomFunction) {
-                return handle.run(default_1.DefaultType.Void, [], ctx);
-            }
-            return handle;
-        });
-    }
-}
-exports.Resolve = Resolve;

package/dist/operations/return.d.ts

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

package/dist/operations/return.js

@@ -1,43 +0,0 @@
-"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.Return = void 0;
-const default_1 = require("../types/default");
-const operation_1 = require("./operation");
-const reference_1 = require("./reference");
-class Return extends operation_1.Operation {
-    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.Reference(default_1.DefaultType.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.DefaultType.Void;
-        });
-    }
-}
-exports.Return = Return;

package/dist/operations/while.d.ts

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

package/dist/operations/while.js

@@ -1,70 +0,0 @@
-"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.While = void 0;
-const context_1 = require("../context");
-const default_1 = require("../types/default");
-const set_immediate_1 = require("../utils/set-immediate");
-const block_1 = require("./block");
-const operation_1 = require("./operation");
-class While extends operation_1.OperationBlock {
-    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.Block(this.item, stack);
-            this.condition = yield visit(this.item.condition);
-            return this;
-        });
-    }
-    handle(ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const whileCtx = ctx.fork({
-                type: context_1.ContextType.Loop,
-                state: context_1.ContextState.Temporary
-            });
-            const loopState = new context_1.LoopState();
-            const exitObserver = ctx.processState.createExitObserver();
-            whileCtx.loopState = loopState;
-            return new Promise((resolve, reject) => {
-                const iteration = () => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const conditionResult = yield whileCtx.step(this.condition);
-                        if (!conditionResult.toTruthy()) {
-                            exitObserver.close();
-                            resolve(default_1.DefaultType.Void);
-                            return;
-                        }
-                        loopState.isContinue = false;
-                        yield this.block.handle(whileCtx);
-                        if (loopState.isBreak ||
-                            whileCtx.functionState.isReturn ||
-                            exitObserver.occured()) {
-                            exitObserver.close();
-                            resolve(default_1.DefaultType.Void);
-                            return;
-                        }
-                        (0, set_immediate_1.setImmediate)(iteration);
-                    }
-                    catch (err) {
-                        exitObserver.close();
-                        reject(err);
-                    }
-                });
-                iteration();
-            });
-        });
-    }
-}
-exports.While = While;

package/dist/utils/create-assign.d.ts

@@ -1,3 +0,0 @@
-import { ASTAssignmentStatement } from 'miniscript-core';
-import { Operation } from '../operations/operation';
-export declare function createAssign(item: ASTAssignmentStatement, target?: string): Operation;

package/dist/utils/create-assign.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAssign = void 0;
-const miniscript_core_1 = require("miniscript-core");
-const assign_1 = require("../operations/assign");
-const assign_globals_1 = require("../operations/assign-globals");
-const assign_locals_1 = require("../operations/assign-locals");
-const assign_outer_1 = require("../operations/assign-outer");
-const assign_self_1 = require("../operations/assign-self");
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-const optAssignMap = {
-    self: assign_self_1.AssignSelf,
-    globals: assign_globals_1.AssignGlobals,
-    locals: assign_locals_1.AssignLocals,
-    outer: assign_outer_1.AssignOuter
-};
-function createAssign(item, target) {
-    if (item.variable instanceof miniscript_core_1.ASTIdentifier &&
-        hasOwnProperty.call(optAssignMap, item.variable.name)) {
-        const OptAssign = optAssignMap[item.variable.name];
-        return new OptAssign(item, target);
-    }
-    return new assign_1.Assign(item, target);
-}
-exports.createAssign = createAssign;

package/dist/utils/create-resolve.d.ts

@@ -1,5 +0,0 @@
-import { ASTBase, ASTIdentifier } from 'miniscript-core';
-import { Operation } from '../operations/operation';
-import { Resolve } from '../operations/resolve';
-export declare function createIdentifierResolve(item: ASTIdentifier, target?: string): Operation;
-export declare function createResolve(item: ASTBase, target?: string): Resolve;

package/dist/utils/create-resolve.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createResolve = exports.createIdentifierResolve = void 0;
-const miniscript_core_1 = require("miniscript-core");
-const reference_globals_1 = require("../operations/reference-globals");
-const reference_locals_1 = require("../operations/reference-locals");
-const reference_outer_1 = require("../operations/reference-outer");
-const reference_self_1 = require("../operations/reference-self");
-const resolve_1 = require("../operations/resolve");
-const resolve_globals_1 = require("../operations/resolve-globals");
-const resolve_locals_1 = require("../operations/resolve-locals");
-const resolve_outer_1 = require("../operations/resolve-outer");
-const resolve_self_1 = require("../operations/resolve-self");
-const lookup_path_1 = require("./lookup-path");
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-const optIdentifierResolveMap = {
-    self: reference_self_1.ReferenceSelf,
-    globals: reference_globals_1.ReferenceGlobals,
-    locals: reference_locals_1.ReferenceLocals,
-    outer: reference_outer_1.ReferenceOuter
-};
-function createIdentifierResolve(item, target) {
-    if (hasOwnProperty.call(optIdentifierResolveMap, item.name)) {
-        const OptResolve = optIdentifierResolveMap[item.name];
-        return new OptResolve(item, target);
-    }
-    return new resolve_1.Resolve(item, target);
-}
-exports.createIdentifierResolve = createIdentifierResolve;
-const optResolveMap = {
-    self: resolve_self_1.ResolveSelf,
-    globals: resolve_globals_1.ResolveGlobals,
-    locals: resolve_locals_1.ResolveLocals,
-    outer: resolve_outer_1.ResolveOuter
-};
-function createResolve(item, target) {
-    if (item instanceof miniscript_core_1.ASTMemberExpression ||
-        item instanceof miniscript_core_1.ASTIndexExpression ||
-        item instanceof miniscript_core_1.ASTSliceExpression) {
-        const path = (0, lookup_path_1.lookupPath)(item);
-        if (path.length > 0 &&
-            path[0].base instanceof miniscript_core_1.ASTIdentifier &&
-            hasOwnProperty.call(optResolveMap, path[0].base.name)) {
-            const OptResolve = optResolveMap[path[0].base.name];
-            path[0].base = null;
-            return new OptResolve(item, target);
-        }
-    }
-    return new resolve_1.Resolve(item, target);
-}
-exports.createResolve = createResolve;

package/dist/utils/path.d.ts

@@ -1,10 +0,0 @@
-export declare class Path<T> {
-    readonly path: Array<T>;
-    constructor(path?: Array<T>);
-    next(): T | null;
-    last(): T | null;
-    add(value: T): void;
-    toString(): string;
-    count(): number;
-    clone(): Path<T>;
-}

package/dist/utils/path.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Path = void 0;
-class Path {
-    constructor(path = []) {
-        this.path = [...path];
-    }
-    next() {
-        if (this.path.length === 0) {
-            return null;
-        }
-        return this.path.shift();
-    }
-    last() {
-        if (this.path.length === 0) {
-            return null;
-        }
-        return this.path.pop();
-    }
-    add(value) {
-        this.path.push(value);
-    }
-    toString() {
-        return this.path.join('.');
-    }
-    count() {
-        return this.path.length;
-    }
-    clone() {
-        return new Path(this.path);
-    }
-}
-exports.Path = Path;