greybel-interpreter 2.6.15 → 2.6.17

package/dist/handler/output.d.ts

@@ -1,13 +1,9 @@
 import { OperationContext } from '../context';
-interface KeyEventWithKeyCode {
-    keyCode: number;
+export interface KeyEvent {
+    keyCode?: number;
+    charCode?: number;
     code: string;
 }
-interface KeyEventWithCharCode {
-    charCode: number;
-    code: string;
-}
-export type KeyEvent = KeyEventWithKeyCode | KeyEventWithCharCode;
 export interface PrintOptions {
     appendNewLine: boolean;
     replace: boolean;
@@ -26,4 +22,3 @@ export declare class DefaultOutputHandler extends OutputHandler {
     waitForKeyPress(_ctx: OperationContext, _message?: string): PromiseLike<KeyEvent>;
     clear(_ctx: OperationContext): void;
 }
-export {};

package/dist/operations/call.js

@@ -13,7 +13,6 @@ exports.Call = void 0;
 const default_1 = require("../types/default");
 const function_1 = require("../types/function");
 const create_resolve_1 = require("../utils/create-resolve");
-const get_super_1 = require("../utils/get-super");
 const operation_1 = require("./operation");
 class Call extends operation_1.Operation {
     constructor(item, target) {
@@ -44,11 +43,11 @@ class Call extends operation_1.Operation {
             }
             if (valueRef instanceof function_1.CustomFunction) {
                 const func = valueRef;
-                const next = (0, get_super_1.getSuper)(resolveResult.handle);
+                const next = func.getNextContext();
                 if (this.fnRef.path.isSuper() && ctx.functionState.context && next) {
-                    return func.run(ctx.functionState.context, fnArgs, ctx, next);
+                    return func.run(ctx.functionState.context, fnArgs, ctx);
                 }
-                return func.run(resolveResult.handle, fnArgs, ctx, next);
+                return func.run(resolveResult.handle, fnArgs, ctx);
             }
             return default_1.DefaultType.Void;
         });

package/dist/operations/function.js

@@ -55,12 +55,13 @@ class FunctionOperation extends operation_1.Operation {
         });
     }
     handle(ctx, assignOuter = false) {
-        const func = new function_1.CustomFunction(ctx, 'anonymous', (fnCtx, self, args, next) => __awaiter(this, void 0, void 0, function* () {
+        const func = new function_1.CustomFunction(ctx, 'anonymous', (fnCtx, self, args) => __awaiter(this, void 0, void 0, function* () {
             const functionState = new context_1.FunctionState();
             functionState.context = self;
             if (self instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
                 fnCtx.set(exports.SELF_PROPERTY, self);
             }
+            const next = func.getNextContext();
             if (next) {
                 fnCtx.set(exports.SUPER_PROPERTY, next);
                 functionState.super = next;

package/dist/operations/resolve.js

@@ -193,7 +193,8 @@ class Resolve extends operation_1.Operation {
                             traversedPath.toString() === function_1.SUPER_NAMESPACE &&
                             ctx.functionState.context &&
                             previous instanceof map_1.CustomMap) {
-                            handle = yield handle.run(ctx.functionState.context, [], ctx, previous.getIsa());
+                            handle.setNextContext(previous.getIsa());
+                            handle = yield handle.run(ctx.functionState.context, [], ctx);
                         }
                         else {
                             handle = yield handle.run(previous || default_1.DefaultType.Void, [], ctx);
@@ -218,7 +219,6 @@ class Resolve extends operation_1.Operation {
         });
     }
     handle(ctx, result = null, autoCall = true) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (result === null) {
                 const exitObserver = ctx.processState.createExitObserver();
@@ -237,20 +237,22 @@ class Resolve extends operation_1.Operation {
                 }
                 if (result.handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
                     const customValueCtx = result.handle;
-                    const next = (0, get_super_1.getSuper)(customValueCtx);
+                    const { value: child, origin } = customValueCtx.getWithOrigin(result.path);
+                    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) {
-                        const superChild = (_a = customValueCtx.getIsa()) === null || _a === void 0 ? void 0 : _a.get(result.path);
-                        if (autoCall && superChild instanceof function_1.CustomFunction) {
+                        if (autoCall && child instanceof function_1.CustomFunction) {
                             if (ctx.functionState.context) {
-                                return superChild.run(ctx.functionState.context, [], ctx, next);
+                                return child.run(ctx.functionState.context, [], ctx);
                             }
-                            return superChild.run(customValueCtx, [], ctx, next);
+                            return child.run(customValueCtx, [], ctx);
                         }
-                        return superChild;
+                        return child;
                     }
-                    const child = customValueCtx.get(result.path);
                     if (autoCall && child instanceof function_1.CustomFunction) {
-                        return child.run(customValueCtx, [], ctx, next);
+                        return child.run(customValueCtx, [], ctx);
                     }
                     return child;
                 }

package/dist/types/function.d.ts

@@ -2,7 +2,6 @@ import { OperationContext } from '../context';
 import { Operation } from '../operations/operation';
 import { ObjectValue } from '../utils/object-value';
 import { CustomValue } from './base';
-import { CustomMap } from './map';
 export interface Callback {
     (ctx: OperationContext, self: CustomValue, args: Map<string, CustomValue>, next?: CustomValue): Promise<NonNullable<CustomValue>>;
 }
@@ -22,6 +21,7 @@ export declare class CustomFunction extends CustomValue {
     readonly value: Callback;
     readonly argumentDefs: Array<Argument>;
     readonly assignOuter: boolean;
+    private _nextContext;
     static createExternalAnonymous(callback: Callback): CustomFunction;
     static createExternal(name: string, callback: Callback): CustomFunction;
     static createExternalWithSelf(name: string, callback: Callback): CustomFunction;
@@ -35,6 +35,8 @@ export declare class CustomFunction extends CustomValue {
     toString(): string;
     toTruthy(): boolean;
     instanceOf(v: CustomValue): boolean;
-    run(self: CustomValue, args: Array<CustomValue>, callContext: OperationContext, next?: CustomMap): Promise<CustomValue>;
+    setNextContext(value: CustomValue): this;
+    getNextContext(): CustomValue;
+    run(self: CustomValue, args: Array<CustomValue>, callContext: OperationContext): Promise<CustomValue>;
     hash(): number;
 }

package/dist/types/function.js

@@ -59,6 +59,7 @@ class CustomFunction extends base_1.CustomValue {
         this.value = callback;
         this.argumentDefs = [];
         this.assignOuter = assignOuter;
+        this._nextContext = null;
     }
     addArgument(name, defaultValue = default_1.DefaultType.Void) {
         this.argumentDefs.push(new Argument(name, defaultValue));
@@ -106,8 +107,15 @@ class CustomFunction extends base_1.CustomValue {
     instanceOf(v) {
         return v.value === CustomFunction.intrinsics;
     }
-    run(self, args, callContext, next) {
-        var _a, _b, _c, _d;
+    setNextContext(value) {
+        this._nextContext = value;
+        return this;
+    }
+    getNextContext() {
+        return this._nextContext;
+    }
+    run(self, args, callContext) {
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             if (args.length > this.argumentDefs.length) {
                 throw new Error('Too many arguments.');
@@ -132,11 +140,13 @@ class CustomFunction extends base_1.CustomValue {
                 argMap.set(item.name, (_d = args[argIndex - selfParam]) !== null && _d !== void 0 ? _d : (yield item.defaultValue.handle(fnCtx)));
             }
             const selfValue = hasSelf ? self : selfWithinArgs;
-            const isa = next !== null && next !== void 0 ? next : (self instanceof map_1.CustomMap ? self.getIsa() : null);
+            const isa = (_e = this.getNextContext()) !== null && _e !== void 0 ? _e : (self instanceof map_1.CustomMap ? self.getIsa() : null);
             if (selfValue) {
                 argMap.set(exports.SELF_NAMESPACE, selfValue);
             }
-            return this.value(fnCtx !== null && fnCtx !== void 0 ? fnCtx : callContext, selfValue, argMap, isa);
+            const result = yield this.value(fnCtx !== null && fnCtx !== void 0 ? fnCtx : callContext, selfValue, argMap, isa);
+            this._nextContext = null;
+            return result;
         });
     }
     hash() {

package/dist/types/list.d.ts

@@ -1,7 +1,7 @@
 import { ObjectValue } from '../utils/object-value';
 import { Path } from '../utils/path';
 import { CustomValue } from './base';
-import { CustomObject } from './with-intrinsics';
+import { CustomObject, CustomValueWithIntrinsicsResult } from './with-intrinsics';
 export declare class CustomListIterator implements Iterator<CustomValue> {
     value: Array<CustomValue>;
     index: number;
@@ -28,5 +28,6 @@ export declare class CustomList extends CustomObject {
     has(path: Path<CustomValue> | CustomValue): boolean;
     set(path: Path<CustomValue> | CustomValue, newValue: CustomValue): void;
     get(path: Path<CustomValue> | CustomValue): CustomValue;
+    getWithOrigin(path: Path<CustomValue> | CustomValue): CustomValueWithIntrinsicsResult;
     hash(recursionDepth?: number): number;
 }

package/dist/types/list.js

@@ -157,6 +157,12 @@ class CustomList extends with_intrinsics_1.CustomObject {
         }
         throw new Error(`Unknown path in list ${path.toString()}.`);
     }
+    getWithOrigin(path) {
+        return {
+            value: this.get(path),
+            origin: null
+        };
+    }
     hash(recursionDepth = 0) {
         let result = (0, hash_1.getHashCode)(this.value.length);
         if (recursionDepth > 16)

package/dist/types/map.d.ts

@@ -2,7 +2,7 @@ import { ObjectValue } from '../utils/object-value';
 import { Path } from '../utils/path';
 import { CustomValue } from './base';
 import { CustomString } from './string';
-import { CustomObject } from './with-intrinsics';
+import { CustomObject, CustomValueWithIntrinsicsResult } from './with-intrinsics';
 export declare const CLASS_ID_PROPERTY: CustomString;
 export declare const ISA_PROPERTY: CustomString;
 export declare const CUSTOM_MAP_MAX_DEPTH = 2;
@@ -32,6 +32,7 @@ export declare class CustomMap extends CustomObject {
     has(path: Path<CustomValue> | CustomValue): boolean;
     set(path: Path<CustomValue> | CustomValue, newValue: CustomValue): void;
     get(path: Path<CustomValue> | CustomValue): CustomValue;
+    getWithOrigin(path: Path<CustomValue> | CustomValue): CustomValueWithIntrinsicsResult;
     createInstance(): CustomMap;
     getIsa(): CustomMap | null;
     hash(recursionDepth?: number): number;

package/dist/types/map.js

@@ -172,6 +172,48 @@ class CustomMap extends with_intrinsics_1.CustomObject {
         }
         throw new Error(`Unknown path in map ${path.toString()}.`);
     }
+    getWithOrigin(path) {
+        if (path instanceof base_1.CustomValue) {
+            return this.getWithOrigin(new path_1.Path([path]));
+        }
+        const traversalPath = path.clone();
+        const current = traversalPath.next();
+        const isa = this.getIsa();
+        if (current !== null) {
+            if (this.value.has(current)) {
+                const sub = this.value.get(current);
+                if (traversalPath.count() > 0) {
+                    if (sub instanceof CustomMap) {
+                        return sub.getWithOrigin(traversalPath);
+                    }
+                    if (sub instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
+                        return {
+                            value: sub.get(traversalPath),
+                            origin: this
+                        };
+                    }
+                }
+                else if (traversalPath.count() === 0) {
+                    return {
+                        value: sub,
+                        origin: this
+                    };
+                }
+            }
+            else if (isa === null || isa === void 0 ? void 0 : isa.has(current)) {
+                return isa.getWithOrigin(current);
+            }
+            else if (traversalPath.count() === 0 &&
+                CustomMap.getIntrinsics().has(current)) {
+                const intrinsics = CustomMap.getIntrinsics();
+                return {
+                    value: intrinsics.get(current),
+                    origin: null
+                };
+            }
+        }
+        throw new Error(`Unknown path in map ${path.toString()}.`);
+    }
     createInstance() {
         const newInstance = new CustomMap(new object_value_1.ObjectValue());
         newInstance.value.set(exports.ISA_PROPERTY, this);

package/dist/types/number.d.ts

@@ -1,7 +1,7 @@
 import { ObjectValue } from '../utils/object-value';
 import { Path } from '../utils/path';
 import { CustomValue } from './base';
-import { CustomValueWithIntrinsics } from './with-intrinsics';
+import { CustomValueWithIntrinsics, CustomValueWithIntrinsicsResult } from './with-intrinsics';
 export declare class CustomNumberIterator implements Iterator<CustomValue> {
     index: number;
     next(): IteratorResult<CustomValue>;
@@ -22,6 +22,7 @@ export declare class CustomNumber extends CustomValueWithIntrinsics {
     has(_path: Path<CustomValue> | CustomValue): boolean;
     set(_path: Path<CustomValue> | CustomValue, _newValue: CustomValue): void;
     get(path: Path<CustomValue> | CustomValue): CustomValue;
+    getWithOrigin(path: Path<CustomValue> | CustomValue): CustomValueWithIntrinsicsResult;
     hash(): number;
 }
 export declare const NegativeOne: CustomNumber;

package/dist/types/number.js

@@ -68,6 +68,12 @@ class CustomNumber extends with_intrinsics_1.CustomValueWithIntrinsics {
         }
         throw new Error(`Unknown path in number ${path.toString()}.`);
     }
+    getWithOrigin(path) {
+        return {
+            value: this.get(path),
+            origin: null
+        };
+    }
     hash() {
         return (0, hash_1.getHashCode)(this.value);
     }

package/dist/types/string.d.ts

@@ -1,7 +1,7 @@
 import { ObjectValue } from '../utils/object-value';
 import { Path } from '../utils/path';
 import { CustomValue } from './base';
-import { CustomValueWithIntrinsics } from './with-intrinsics';
+import { CustomValueWithIntrinsics, CustomValueWithIntrinsicsResult } from './with-intrinsics';
 export declare class CustomStringIterator implements Iterator<CustomValue> {
     value: string;
     index: number;
@@ -30,5 +30,6 @@ export declare class CustomString extends CustomValueWithIntrinsics {
     has(path: Path<CustomValue> | CustomValue): boolean;
     set(_path: Path<CustomValue> | CustomValue, _newValue: CustomValue): void;
     get(path: Path<CustomValue> | CustomValue): CustomValue;
+    getWithOrigin(path: Path<CustomValue> | CustomValue): CustomValueWithIntrinsicsResult;
     hash(): number;
 }

package/dist/types/string.js

@@ -119,6 +119,12 @@ class CustomString extends with_intrinsics_1.CustomValueWithIntrinsics {
         }
         throw new Error(`Unknown path in string ${path.toString()}.`);
     }
+    getWithOrigin(path) {
+        return {
+            value: this.get(path),
+            origin: null
+        };
+    }
     hash() {
         return (0, hash_1.getStringHashCode)(this.value);
     }

package/dist/types/with-intrinsics.d.ts

@@ -2,10 +2,15 @@ import { ObjectValue } from '../utils/object-value';
 import { Path } from '../utils/path';
 import { CustomValue } from './base';
 import { CustomFunction } from './function';
+export type CustomValueWithIntrinsicsResult = {
+    value: CustomValue;
+    origin: CustomValueWithIntrinsics;
+};
 export declare abstract class CustomValueWithIntrinsics extends CustomValue {
     abstract has(path: Path<CustomValue> | CustomValue): boolean;
     abstract set(path: Path<CustomValue> | CustomValue, value: CustomValue): void;
     abstract get(path: Path<CustomValue> | CustomValue): CustomValue;
+    abstract getWithOrigin(path: Path<CustomValue> | CustomValue): CustomValueWithIntrinsicsResult;
     abstract [Symbol.iterator](): Iterator<CustomValue> & {
         index: number;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greybel-interpreter",
-    "version": "2.6.15",
+    "version": "2.6.17",
     "description": "Interpreter",
     "main": "dist/index",
     "typings": "dist/index",