greybel-interpreter 1.4.4 → 1.4.5

package/dist/context.d.ts

@@ -2,9 +2,10 @@ import { ASTBase } from 'greyscript-core';
 import CPS from './cps';
 import HandlerContainer from './handler-container';
 import Operation from './operations/operation';
-import { CustomValue } from './types/generics';
+import CustomValue from './types/base';
 import CustomMap from './types/map';
 import CustomNil from './types/nil';
+import ObjectValue from './utils/object-value';
 import Path from './utils/path';
 export declare enum ContextType {
     Api = 0,
@@ -102,7 +103,7 @@ export default class OperationContext {
     lookupApi(): OperationContext;
     lookupGlobals(): OperationContext;
     lookupLocals(): OperationContext;
-    extend(map: Map<CustomValue, CustomValue>): OperationContext;
+    extend(map: ObjectValue): OperationContext;
     set(path: Path<CustomValue> | CustomValue, value: CustomValue): void;
     get(path: Path<CustomValue> | CustomValue): CustomValue;
     fork(options: ContextForkOptions): OperationContext;

package/dist/context.js

@@ -1,54 +1,14 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionState = exports.LoopState = exports.ProcessState = exports.Debugger = exports.Scope = exports.ContextState = exports.ContextType = void 0;
-var handler_container_1 = __importDefault(require("./handler-container"));
-var default_1 = __importDefault(require("./types/default"));
-var generics_1 = require("./types/generics");
-var map_1 = __importDefault(require("./types/map"));
-var path_1 = __importDefault(require("./utils/path"));
+const handler_container_1 = __importDefault(require("./handler-container"));
+const base_1 = __importDefault(require("./types/base"));
+const default_1 = __importDefault(require("./types/default"));
+const map_1 = __importDefault(require("./types/map"));
+const path_1 = __importDefault(require("./utils/path"));
 var ContextType;
 (function (ContextType) {
     ContextType[ContextType["Api"] = 0] = "Api";
@@ -64,84 +24,72 @@ var ContextState;
     ContextState[ContextState["Temporary"] = 0] = "Temporary";
     ContextState[ContextState["Default"] = 1] = "Default";
 })(ContextState = exports.ContextState || (exports.ContextState = {}));
-var Scope = /** @class */ (function (_super) {
-    __extends(Scope, _super);
-    function Scope(context) {
-        var _this = _super.call(this) || this;
-        _this.context = context;
-        return _this;
+class Scope extends map_1.default {
+    constructor(context) {
+        super();
+        this.context = context;
     }
-    Scope.prototype.get = function (path) {
-        if (path instanceof generics_1.CustomValue) {
+    get(path) {
+        if (path instanceof base_1.default) {
             return this.get(new path_1.default([path]));
         }
         if (path.count() === 0) {
             return this;
         }
-        var traversalPath = path.clone();
-        var current = traversalPath.next();
-        if (current.value === 'locals' || current.value === 'globals') {
-            return this.context.get(traversalPath);
-        }
-        else if (this.has(path)) {
-            return _super.prototype.get.call(this, path);
+        const traversalPath = path.clone();
+        const current = traversalPath.next();
+        if (this.has(path)) {
+            return super.get(path);
         }
         else if (this.context.api.scope.has(path)) {
             return this.context.api.scope.get(path);
         }
-        else if (path.count() === 1 &&
-            map_1.default.getIntrinsics().has(current.toString())) {
-            return map_1.default.getIntrinsics().get(current.toString());
+        else if (path.count() === 1 && map_1.default.getIntrinsics().has(current)) {
+            return map_1.default.getIntrinsics().get(current);
         }
         else if (this.context.previous !== null) {
             return this.context.previous.get(path);
         }
-        throw new Error("Unknown path ".concat(path.toString(), "."));
-    };
-    return Scope;
-}(map_1.default));
+        throw new Error(`Unknown path ${path.toString()}.`);
+    }
+}
 exports.Scope = Scope;
-var Debugger = /** @class */ (function () {
-    function Debugger() {
+class Debugger {
+    constructor() {
         this.breakpoint = false;
         this.nextStep = false;
         /* eslint-disable no-use-before-define */
         this.lastContext = null;
     }
-    Debugger.prototype.getLastContext = function () {
+    getLastContext() {
         return this.lastContext;
-    };
-    Debugger.prototype.debug = function () {
-        var segments = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            segments[_i] = arguments[_i];
-        }
-        console.debug.apply(console, __spreadArray([], __read(segments), false));
+    }
+    debug(...segments) {
+        console.debug(...segments);
         return default_1.default.Void;
-    };
-    Debugger.prototype.setBreakpoint = function (breakpoint) {
+    }
+    setBreakpoint(breakpoint) {
         this.breakpoint = breakpoint;
         return this;
-    };
-    Debugger.prototype.getBreakpoint = function (_ctx) {
+    }
+    getBreakpoint(_ctx) {
         return this.breakpoint;
-    };
-    Debugger.prototype.next = function () {
+    }
+    next() {
         this.nextStep = true;
         return this;
-    };
-    Debugger.prototype.resume = function () {
-        var _this = this;
+    }
+    resume() {
         if (!this.breakpoint) {
             return Promise.resolve();
         }
-        return new Promise(function (resolve) {
-            var check = function () {
-                if (!_this.breakpoint) {
+        return new Promise((resolve) => {
+            const check = () => {
+                if (!this.breakpoint) {
                     resolve();
                 }
-                else if (_this.nextStep) {
-                    _this.nextStep = false;
+                else if (this.nextStep) {
+                    this.nextStep = false;
                     resolve();
                 }
                 else {
@@ -150,45 +98,40 @@ var Debugger = /** @class */ (function () {
             };
             check();
         });
-    };
-    Debugger.prototype.interact = function (ctx, _ast, _op) {
-        var me = this;
+    }
+    interact(ctx, _ast, _op) {
+        const me = this;
         console.warn('Debugger is not setup.');
         console.info(ctx);
         me.breakpoint = false;
-    };
-    return Debugger;
-}());
+    }
+}
 exports.Debugger = Debugger;
-var ProcessState = /** @class */ (function () {
-    function ProcessState() {
+class ProcessState {
+    constructor() {
         this.isExit = false;
         this.isPending = false;
         /* eslint-disable no-use-before-define */
         this.last = null;
     }
-    return ProcessState;
-}());
+}
 exports.ProcessState = ProcessState;
-var LoopState = /** @class */ (function () {
-    function LoopState() {
+class LoopState {
+    constructor() {
         this.isBreak = false;
         this.isContinue = false;
     }
-    return LoopState;
-}());
+}
 exports.LoopState = LoopState;
-var FunctionState = /** @class */ (function () {
-    function FunctionState() {
+class FunctionState {
+    constructor() {
         this.value = default_1.default.Void;
         this.isReturn = false;
     }
-    return FunctionState;
-}());
+}
 exports.FunctionState = FunctionState;
-var OperationContext = /** @class */ (function () {
-    function OperationContext(options) {
-        if (options === void 0) { options = {}; }
+class OperationContext {
+    constructor(options = {}) {
         this.target = options.target || 'unknown';
         this.stackItem = null;
         this.previous = options.previous || null;
@@ -205,7 +148,7 @@ var OperationContext = /** @class */ (function () {
         this.globals = this.lookupGlobals();
         this.locals = this.lookupLocals() || this;
     }
-    OperationContext.prototype.step = function (op) {
+    step(op) {
         if (!this.injected) {
             this.stackItem = op.item;
             this.target = op.target || this.target;
@@ -216,33 +159,33 @@ var OperationContext = /** @class */ (function () {
             }
         }
         return Promise.resolve();
-    };
-    OperationContext.prototype.setLastActive = function (ctx) {
+    }
+    setLastActive(ctx) {
         if (!ctx.injected) {
             this.processState.last = ctx;
         }
         return this;
-    };
-    OperationContext.prototype.getLastActive = function () {
+    }
+    getLastActive() {
         return this.processState.last;
-    };
-    OperationContext.prototype.isExit = function () {
+    }
+    isExit() {
         return this.processState.isExit;
-    };
-    OperationContext.prototype.isPending = function () {
+    }
+    isPending() {
         return this.processState.isPending;
-    };
-    OperationContext.prototype.setPending = function (pending) {
+    }
+    setPending(pending) {
         this.processState.isPending = pending;
         return this;
-    };
-    OperationContext.prototype.lookupAllOfType = function (validate) {
-        var me = this;
-        var result = [];
+    }
+    lookupAllOfType(validate) {
+        const me = this;
+        const result = [];
         if (validate(me.type)) {
             result.push(me);
         }
-        var current = me.previous;
+        let current = me.previous;
         while (current) {
             if (validate(current.type)) {
                 result.push(current);
@@ -250,16 +193,15 @@ var OperationContext = /** @class */ (function () {
             current = current.previous;
         }
         return result;
-    };
-    OperationContext.prototype.exit = function () {
-        var _this = this;
+    }
+    exit() {
         if (this.processState.isPending) {
             this.processState.isExit = true;
-            return new Promise(function (resolve) {
-                var check = function () {
-                    if (!_this.processState.isPending) {
-                        _this.processState.isExit = false;
-                        resolve(_this);
+            return new Promise((resolve) => {
+                const check = () => {
+                    if (!this.processState.isPending) {
+                        this.processState.isExit = false;
+                        resolve(this);
                     }
                     else {
                         setTimeout(check);
@@ -269,12 +211,12 @@ var OperationContext = /** @class */ (function () {
             });
         }
         return Promise.reject(new Error('No running process found.'));
-    };
-    OperationContext.prototype.lookupType = function (allowedTypes) {
+    }
+    lookupType(allowedTypes) {
         if (allowedTypes.includes(this.type)) {
             return this;
         }
-        var current = this.previous;
+        let current = this.previous;
         while (current !== null) {
             if (allowedTypes.includes(current.type)) {
                 return current;
@@ -282,22 +224,20 @@ var OperationContext = /** @class */ (function () {
             current = current.previous;
         }
         return null;
-    };
-    OperationContext.prototype.lookupAllScopes = function () {
-        return this.lookupAllOfType(function (type) {
-            return [ContextType.Global, ContextType.Function].includes(type);
-        });
-    };
-    OperationContext.prototype.lookupApi = function () {
+    }
+    lookupAllScopes() {
+        return this.lookupAllOfType((type) => [ContextType.Global, ContextType.Function].includes(type));
+    }
+    lookupApi() {
         return this.lookupType(OperationContext.lookupApiType);
-    };
-    OperationContext.prototype.lookupGlobals = function () {
+    }
+    lookupGlobals() {
         return this.lookupType(OperationContext.lookupGlobalsType);
-    };
-    OperationContext.prototype.lookupLocals = function () {
+    }
+    lookupLocals() {
         return this.lookupType(OperationContext.lookupLocalsType);
-    };
-    OperationContext.prototype.extend = function (map) {
+    }
+    extend(map) {
         var _a;
         if (this.state === ContextState.Temporary) {
             (_a = this.previous) === null || _a === void 0 ? void 0 : _a.extend(map);
@@ -306,51 +246,35 @@ var OperationContext = /** @class */ (function () {
             this.scope.extend(map);
         }
         return this;
-    };
-    OperationContext.prototype.set = function (path, value) {
+    }
+    set(path, value) {
         var _a;
-        if (path instanceof generics_1.CustomValue) {
+        if (path instanceof base_1.default) {
             this.set(new path_1.default([path]), value);
             return;
         }
-        var traversalPath = path.clone();
-        var current = traversalPath.next();
-        if (current.value === 'locals') {
-            this.locals.set(traversalPath, value);
-        }
-        else if (current.value === 'globals') {
-            this.globals.set(traversalPath, value);
-        }
-        else if (this.state === ContextState.Temporary) {
+        if (this.state === ContextState.Temporary) {
             (_a = this.previous) === null || _a === void 0 ? void 0 : _a.set(path, value);
         }
         else {
             this.locals.scope.set(path, value);
         }
-    };
-    OperationContext.prototype.get = function (path) {
+    }
+    get(path) {
         var _a;
-        if (path instanceof generics_1.CustomValue) {
+        if (path instanceof base_1.default) {
             return this.get(new path_1.default([path]));
         }
         if (path.count() === 0) {
             return this.scope;
         }
-        var traversalPath = path.clone();
-        var current = traversalPath.next();
-        if (current.value === 'locals') {
-            return this.locals.get(traversalPath);
-        }
-        else if (current.value === 'globals') {
-            return this.globals.get(traversalPath);
-        }
-        else if (this.state === ContextState.Temporary) {
+        if (this.state === ContextState.Temporary) {
             return (_a = this.previous) === null || _a === void 0 ? void 0 : _a.get(path);
         }
         return this.locals.scope.get(path);
-    };
-    OperationContext.prototype.fork = function (options) {
-        var newContext = new OperationContext({
+    }
+    fork(options) {
+        const newContext = new OperationContext({
             target: options.target || this.target,
             previous: this,
             type: options.type,
@@ -369,15 +293,14 @@ var OperationContext = /** @class */ (function () {
             newContext.functionState = this.functionState;
         }
         return newContext;
-    };
-    OperationContext.lookupApiType = [ContextType.Api];
-    OperationContext.lookupGlobalsType = [
-        ContextType.Global
-    ];
-    OperationContext.lookupLocalsType = [
-        ContextType.Global,
-        ContextType.Function
-    ];
-    return OperationContext;
-}());
+    }
+}
 exports.default = OperationContext;
+OperationContext.lookupApiType = [ContextType.Api];
+OperationContext.lookupGlobalsType = [
+    ContextType.Global
+];
+OperationContext.lookupLocalsType = [
+    ContextType.Global,
+    ContextType.Function
+];