greybel-interpreter 2.2.20 → 2.3.1

package/dist/context.js

@@ -61,12 +61,9 @@ class Scope extends map_1.CustomMap {
         else if ((_c = this.context.api) === null || _c === void 0 ? void 0 : _c.scope.has(path)) {
             return this.context.api.scope.get(path);
         }
-        else if (path.count() === 1 && map_1.CustomMap.getIntrinsics().has(current)) {
+        else if (traversalPath.count() === 0 && map_1.CustomMap.getIntrinsics().has(current)) {
             return map_1.CustomMap.getIntrinsics().get(current);
         }
-        else if (this.context.previous !== null) {
-            return this.context.previous.get(path);
-        }
         throw new Error(`Unknown path ${path.toString()}.`);
     }
 }

package/dist/cps.js

@@ -12,7 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CPS = exports.CPSContext = void 0;
 const greybel_core_1 = require("greybel-core");
 const greyscript_core_1 = require("greyscript-core");
-const assign_1 = require("./operations/assign");
 const break_1 = require("./operations/break");
 const call_1 = require("./operations/call");
 const chunk_1 = require("./operations/chunk");
@@ -37,6 +36,8 @@ const resolve_1 = require("./operations/resolve");
 const return_1 = require("./operations/return");
 const while_1 = require("./operations/while");
 const error_1 = require("./utils/error");
+const create_resolve_1 = require("./utils/create-resolve");
+const create_assign_1 = require("./utils/create-assign");
 class CPSContext {
     constructor(target, handler) {
         this.target = target;
@@ -53,9 +54,11 @@ const visit = (context, stack, item) => __awaiter(void 0, void 0, void 0, functi
         case greyscript_core_1.ASTType.ListConstructorExpression:
             return new list_1.List(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.AssignmentStatement:
-            return new assign_1.Assign(item, currentTarget).build(defaultVisit);
+            return (0, create_assign_1.createAssign)(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.MemberExpression:
+            return (0, create_resolve_1.createResolve)(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.Identifier:
+            return (0, create_resolve_1.createIdentifierResolve)(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.IndexExpression:
         case greyscript_core_1.ASTType.SliceExpression:
             return new resolve_1.Resolve(item, currentTarget).build(defaultVisit);

package/dist/interpreter.js

@@ -162,7 +162,6 @@ class Interpreter extends events_1.EventEmitter {
             const newParams = new list_1.CustomList(this.params.map((item) => new string_1.CustomString(item)));
             this.globalContext.scope.set(exports.IS_GREYBEL_PROPERTY, new boolean_1.CustomBoolean(true));
             this.globalContext.scope.set(exports.PARAMS_PROPERTY, newParams);
-            this.globalContext.set(new string_1.CustomString('globals'), this.globalContext.scope);
             try {
                 this.apiContext.setPending(true);
                 const process = top.handle(this.globalContext);

package/dist/operations/assign-globals.d.ts

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

package/dist/operations/assign-globals.js

@@ -0,0 +1,31 @@
+"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.AssignGlobals = void 0;
+const operation_1 = require("./operation");
+class AssignGlobals extends operation_1.Operation {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.right = yield visit(this.item.init);
+            return this;
+        });
+    }
+    handle(_ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Cannot assign to globals.');
+        });
+    }
+}
+exports.AssignGlobals = AssignGlobals;

package/dist/operations/assign-locals.d.ts

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

package/dist/operations/assign-locals.js

@@ -0,0 +1,31 @@
+"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.AssignLocals = void 0;
+const operation_1 = require("./operation");
+class AssignLocals extends operation_1.Operation {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.right = yield visit(this.item.init);
+            return this;
+        });
+    }
+    handle(_ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Cannot assign to locals.');
+        });
+    }
+}
+exports.AssignLocals = AssignLocals;

package/dist/operations/assign-outer.d.ts

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

package/dist/operations/assign-outer.js

@@ -0,0 +1,31 @@
+"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.AssignOuter = void 0;
+const operation_1 = require("./operation");
+class AssignOuter extends operation_1.Operation {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.right = yield visit(this.item.init);
+            return this;
+        });
+    }
+    handle(_ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Cannot assign to outer.');
+        });
+    }
+}
+exports.AssignOuter = AssignOuter;

package/dist/operations/assign-self.d.ts

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

package/dist/operations/assign-self.js

@@ -0,0 +1,34 @@
+"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.AssignSelf = void 0;
+const default_1 = require("../types/default");
+const operation_1 = require("./operation");
+class AssignSelf extends operation_1.Operation {
+    constructor(item, target) {
+        super(null, target);
+        this.item = item;
+    }
+    build(visit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.right = yield visit(this.item.init);
+            return this;
+        });
+    }
+    handle(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rightValue = yield this.right.handle(ctx);
+            ctx.functionState.context = rightValue;
+            return default_1.DefaultType.Void;
+        });
+    }
+}
+exports.AssignSelf = AssignSelf;

package/dist/operations/assign.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Assign = void 0;
 const default_1 = require("../types/default");
+const create_resolve_1 = require("../utils/create-resolve");
 const operation_1 = require("./operation");
 const resolve_1 = require("./resolve");
 class Assign extends operation_1.Operation {
@@ -20,7 +21,7 @@ class Assign extends operation_1.Operation {
     }
     build(visit) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.left = new resolve_1.Resolve(this.item.variable);
+            this.left = (0, create_resolve_1.createResolve)(this.item.variable, this.target);
             yield this.left.build(visit);
             this.right = yield visit(this.item.init);
             return this;
@@ -33,6 +34,9 @@ class Assign extends operation_1.Operation {
                 return default_1.DefaultType.Void;
             }
             const rightValue = yield this.right.handle(ctx);
+            if (resolveResult.path.count() === 0) {
+                throw new Error('Resolve path cannot be empty.');
+            }
             if (!(resolveResult.handle instanceof resolve_1.ResolveNil)) {
                 const resultValueCtx = resolveResult.handle;
                 resultValueCtx.set(resolveResult.path, rightValue);

package/dist/operations/call.js

@@ -12,9 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Call = void 0;
 const default_1 = require("../types/default");
 const function_1 = require("../types/function");
-const map_1 = require("../types/map");
+const create_resolve_1 = require("../utils/create-resolve");
+const get_super_1 = require("../utils/get-super");
 const operation_1 = require("./operation");
-const resolve_1 = require("./resolve");
 class Call extends operation_1.Operation {
     constructor(item, target) {
         super(null, target);
@@ -22,7 +22,7 @@ class Call extends operation_1.Operation {
     }
     build(visit) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.fnRef = new resolve_1.Resolve(this.item.base);
+            this.fnRef = (0, create_resolve_1.createResolve)(this.item.base, this.target);
             yield this.fnRef.build(visit);
             const args = this.item.arguments.map((arg) => visit(arg));
             this.args = yield Promise.all(args);
@@ -42,12 +42,11 @@ class Call extends operation_1.Operation {
             }
             if (valueRef instanceof function_1.CustomFunction) {
                 const func = valueRef;
-                if (this.fnRef.path.isSuper() &&
-                    ctx.functionState.context &&
-                    resolveResult.handle instanceof map_1.CustomMap) {
-                    return func.run(ctx.functionState.context, fnArgs, ctx, resolveResult.handle.getIsa());
+                const next = (0, get_super_1.getSuper)(resolveResult.handle);
+                if (this.fnRef.path.isSuper() && ctx.functionState.context && next) {
+                    return func.run(ctx.functionState.context, fnArgs, ctx, next);
                 }
-                return func.run(resolveResult.handle, fnArgs, ctx);
+                return func.run(resolveResult.handle, fnArgs, ctx, next);
             }
             return default_1.DefaultType.Void;
         });

package/dist/operations/chunk.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Chunk = void 0;
-const string_1 = require("../types/string");
 const block_1 = require("./block");
 const operation_1 = require("./operation");
 class Chunk extends operation_1.OperationBlock {
@@ -26,7 +25,6 @@ class Chunk extends operation_1.OperationBlock {
         });
     }
     handle(ctx) {
-        ctx.set(new string_1.CustomString('locals'), ctx.locals.scope);
         return this.block.handle(ctx);
     }
 }

package/dist/operations/function-reference.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionReference = void 0;
 const default_1 = require("../types/default");
+const create_resolve_1 = require("../utils/create-resolve");
 const operation_1 = require("./operation");
 const resolve_1 = require("./resolve");
 class FunctionReference extends operation_1.Operation {
@@ -20,7 +21,7 @@ class FunctionReference extends operation_1.Operation {
     }
     build(visit) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.ref = new resolve_1.Resolve(this.item.argument);
+            this.ref = (0, create_resolve_1.createResolve)(this.item.argument, this.target);
             yield this.ref.build(visit);
             return this;
         });

package/dist/operations/function.js

@@ -15,6 +15,7 @@ const context_1 = require("../context");
 const default_1 = require("../types/default");
 const function_1 = require("../types/function");
 const string_1 = require("../types/string");
+const with_intrinsics_1 = require("../types/with-intrinsics");
 const block_1 = require("./block");
 const operation_1 = require("./operation");
 const reference_1 = require("./reference");
@@ -56,15 +57,17 @@ class FunctionOperation extends operation_1.Operation {
     handle(ctx) {
         const func = new function_1.CustomFunction(ctx, 'anonymous', (fnCtx, self, args, next) => __awaiter(this, void 0, void 0, function* () {
             const functionState = new context_1.FunctionState();
-            fnCtx.set(exports.SELF_PROPERTY, self);
             functionState.context = self;
+            if (self instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
+                fnCtx.set(exports.SELF_PROPERTY, self);
+            }
             if (next) {
                 fnCtx.set(exports.SUPER_PROPERTY, next);
                 functionState.super = next;
             }
-            fnCtx.set(new string_1.CustomString('locals'), fnCtx.locals.scope);
-            fnCtx.set(new string_1.CustomString('outer'), fnCtx.previous.locals.scope);
             for (const [key, value] of args) {
+                if (key === function_1.SELF_NAMESPACE)
+                    continue;
                 fnCtx.set(new string_1.CustomString(key), value);
             }
             fnCtx.functionState = functionState;

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

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceGlobals extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceGlobals>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-globals.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceGlobals = void 0;
+const operation_1 = require("./operation");
+class ReferenceGlobals extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.globals.scope);
+    }
+}
+exports.ReferenceGlobals = ReferenceGlobals;

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

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceLocals extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceLocals>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-locals.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceLocals = void 0;
+const operation_1 = require("./operation");
+class ReferenceLocals extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.locals.scope);
+    }
+}
+exports.ReferenceLocals = ReferenceLocals;

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

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceOuter extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceOuter>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-outer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceOuter = void 0;
+const operation_1 = require("./operation");
+class ReferenceOuter extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.outer.scope);
+    }
+}
+exports.ReferenceOuter = ReferenceOuter;

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

@@ -0,0 +1,7 @@
+import { OperationContext } from '../context';
+import { CustomValue } from '../types/base';
+import { CPSVisit, Operation } from './operation';
+export declare class ReferenceSelf extends Operation {
+    build(_visit: CPSVisit): Promise<ReferenceSelf>;
+    handle(ctx: OperationContext): Promise<CustomValue>;
+}

package/dist/operations/reference-self.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceSelf = void 0;
+const operation_1 = require("./operation");
+class ReferenceSelf extends operation_1.Operation {
+    build(_visit) {
+        return Promise.resolve(this);
+    }
+    handle(ctx) {
+        return Promise.resolve(ctx.functionState.context);
+    }
+}
+exports.ReferenceSelf = ReferenceSelf;

package/dist/operations/resolve-globals.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveGlobals extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-globals.js

@@ -0,0 +1,24 @@
+"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.ResolveGlobals = void 0;
+const resolve_1 = require("./resolve");
+class ResolveGlobals extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.globals.scope);
+        });
+    }
+}
+exports.ResolveGlobals = ResolveGlobals;

package/dist/operations/resolve-locals.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveLocals extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-locals.js

@@ -0,0 +1,24 @@
+"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.ResolveLocals = void 0;
+const resolve_1 = require("./resolve");
+class ResolveLocals extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.locals.scope);
+        });
+    }
+}
+exports.ResolveLocals = ResolveLocals;

package/dist/operations/resolve-outer.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveOuter extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-outer.js

@@ -0,0 +1,24 @@
+"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.ResolveOuter = void 0;
+const resolve_1 = require("./resolve");
+class ResolveOuter extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.outer.scope);
+        });
+    }
+}
+exports.ResolveOuter = ResolveOuter;

package/dist/operations/resolve-self.d.ts

@@ -0,0 +1,5 @@
+import { OperationContext } from '../context';
+import { Resolve, ResolveResult } from './resolve';
+export declare class ResolveSelf extends Resolve {
+    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+}

package/dist/operations/resolve-self.js

@@ -0,0 +1,24 @@
+"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.ResolveSelf = void 0;
+const resolve_1 = require("./resolve");
+class ResolveSelf extends resolve_1.Resolve {
+    getResult(ctx) {
+        const _super = Object.create(null, {
+            getResult: { get: () => super.getResult }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getResult.call(this, ctx, ctx.functionState.context);
+        });
+    }
+}
+exports.ResolveSelf = ResolveSelf;

package/dist/operations/resolve.d.ts

@@ -50,6 +50,6 @@ export declare class Resolve extends Operation {
     constructor(item: ASTBase, target?: string);
     buildProcessor(node: ASTBase, visit: CPSVisit): Promise<void>;
     build(visit: CPSVisit): Promise<Resolve>;
-    getResult(ctx: OperationContext): Promise<ResolveResult | null>;
+    getResult(ctx: OperationContext, handle?: CustomValue): Promise<ResolveResult | null>;
     handle(ctx: OperationContext, result?: ResolveResult, autoCall?: boolean): Promise<CustomValue>;
 }

package/dist/operations/resolve.js

@@ -18,6 +18,7 @@ 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 {
@@ -149,15 +150,15 @@ class Resolve extends operation_1.Operation {
             return this;
         });
     }
-    getResult(ctx) {
+    getResult(ctx, handle = new ResolveNil()) {
         return __awaiter(this, void 0, void 0, function* () {
             let traversedPath = new path_1.Path();
-            let handle = new ResolveNil();
+            let index = 0;
             const maxIndex = this.path.count();
             const lastIndex = maxIndex - 1;
-            for (let index = 0; index < maxIndex; index++) {
+            for (; index < maxIndex; index++) {
                 if (ctx.isExit()) {
-                    return new ResolveResult(null, default_1.DefaultType.Void);
+                    return new ResolveResult(null, new ResolveNil());
                 }
                 const current = this.path.at(index);
                 if (current instanceof OperationSegment) {
@@ -228,19 +229,20 @@ 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);
                     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 (ctx.functionState.context) {
-                                return superChild.run(ctx.functionState.context, [], ctx, customValueCtx.getIsa());
+                                return superChild.run(ctx.functionState.context, [], ctx, next);
                             }
-                            return superChild.run(customValueCtx, [], ctx);
+                            return superChild.run(customValueCtx, [], ctx, next);
                         }
                         return superChild;
                     }
                     const child = customValueCtx.get(result.path);
                     if (autoCall && child instanceof function_1.CustomFunction) {
-                        return child.run(customValueCtx, [], ctx);
+                        return child.run(customValueCtx, [], ctx, next);
                     }
                     return child;
                 }

package/dist/types/function.js

@@ -104,40 +104,34 @@ class CustomFunction extends base_1.CustomValue {
         return v.value === CustomFunction.intrinsics;
     }
     run(self, args, callContext, next) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
+            if (args.length > this.argumentDefs.length) {
+                throw new Error('Too many arguments.');
+            }
             const fnCtx = (_a = this.scope) === null || _a === void 0 ? void 0 : _a.fork({
                 type: context_1.ContextType.Function,
                 state: context_1.ContextState.Default
             });
             const argMap = new Map();
-            const isSelfNull = self instanceof nil_1.CustomNil;
-            let index = 0;
-            if (!isSelfNull) {
-                for (; index < this.argumentDefs.length; index++) {
-                    const item = this.argumentDefs[index];
-                    if (item.name !== exports.SELF_NAMESPACE)
-                        break;
-                }
-            }
-            let argIndex = 0;
-            for (; index < this.argumentDefs.length; index++) {
-                const item = this.argumentDefs[index];
-                if (!isSelfNull && item.name === exports.SELF_NAMESPACE) {
-                    argIndex++;
+            const hasSelf = !(self instanceof nil_1.CustomNil);
+            let selfWithinArgs = default_1.DefaultType.Void;
+            let argIndex = this.argumentDefs.length - 1;
+            const selfParam = hasSelf && ((_b = this.argumentDefs[0]) === null || _b === void 0 ? void 0 : _b.name) === exports.SELF_NAMESPACE ? 1 : 0;
+            for (; argIndex >= selfParam; argIndex--) {
+                const item = this.argumentDefs[argIndex];
+                if (item.name === exports.SELF_NAMESPACE) {
+                    selfWithinArgs = (_c = args[argIndex - selfParam]) !== null && _c !== void 0 ? _c : default_1.DefaultType.Void;
                     continue;
                 }
-                if (argMap.has(item.name)) {
-                    argIndex++;
-                    continue;
-                }
-                argMap.set(item.name, (_b = args[argIndex++]) !== null && _b !== void 0 ? _b : (yield item.defaultValue.handle(fnCtx)));
-            }
-            if (!isSelfNull) {
-                argMap.set(exports.SELF_NAMESPACE, self);
+                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);
-            return this.value(fnCtx !== null && fnCtx !== void 0 ? fnCtx : callContext, self, argMap, isa);
+            if (selfValue) {
+                argMap.set(exports.SELF_NAMESPACE, selfValue);
+            }
+            return this.value(fnCtx !== null && fnCtx !== void 0 ? fnCtx : callContext, selfValue, argMap, isa);
         });
     }
 }

package/dist/types/map.js

@@ -164,7 +164,8 @@ class CustomMap extends with_intrinsics_1.CustomObject {
             else if (isa === null || isa === void 0 ? void 0 : isa.has(current)) {
                 return isa.get(current);
             }
-            else if (path.count() === 1 && CustomMap.getIntrinsics().has(current)) {
+            else if (traversalPath.count() === 0 &&
+                CustomMap.getIntrinsics().has(current)) {
                 return CustomMap.getIntrinsics().get(current);
             }
         }

package/dist/types/number.js

@@ -4,7 +4,6 @@ exports.Zero = exports.PositiveOne = exports.NegativeOne = exports.CustomNumber
 const object_value_1 = require("../utils/object-value");
 const path_1 = require("../utils/path");
 const base_1 = require("./base");
-const nil_1 = require("./nil");
 const with_intrinsics_1 = require("./with-intrinsics");
 class CustomNumberIterator {
     constructor() {
@@ -62,10 +61,11 @@ class CustomNumber extends with_intrinsics_1.CustomValueWithIntrinsics {
         }
         const traversalPath = path.clone();
         const current = traversalPath.next();
-        if (path.count() === 1 && CustomNumber.getIntrinsics().has(current)) {
+        if (traversalPath.count() === 0 &&
+            CustomNumber.getIntrinsics().has(current)) {
             return CustomNumber.intrinsics.get(current);
         }
-        return nil_1.Void;
+        throw new Error(`Unknown path in number ${path.toString()}.`);
     }
 }
 CustomNumber.intrinsics = new object_value_1.ObjectValue();

package/dist/types/string.js

@@ -4,7 +4,6 @@ exports.CustomString = exports.CustomStringIterator = void 0;
 const object_value_1 = require("../utils/object-value");
 const path_1 = require("../utils/path");
 const base_1 = require("./base");
-const default_1 = require("./default");
 const number_1 = require("./number");
 const with_intrinsics_1 = require("./with-intrinsics");
 class CustomStringIterator {
@@ -113,11 +112,11 @@ class CustomString extends with_intrinsics_1.CustomValueWithIntrinsics {
             }
             throw new Error(`Index error (string index ${currentIndex} out of range).`);
         }
-        else if (path.count() === 1 &&
+        else if (traversalPath.count() === 0 &&
             CustomString.getIntrinsics().has(current)) {
             return CustomString.intrinsics.get(current);
         }
-        return default_1.DefaultType.Void;
+        throw new Error(`Unknown path in string ${path.toString()}.`);
     }
 }
 CustomString.intrinsics = new object_value_1.ObjectValue();

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

@@ -12,6 +12,7 @@ export declare abstract class CustomValueWithIntrinsics extends CustomValue {
     static readonly intrinsics: ObjectValue;
     static getIntrinsics(): ObjectValue;
     static addIntrinsic(key: CustomValue, fn: CustomFunction): void;
+    getIntrinsics(): ObjectValue;
 }
 export declare abstract class CustomObject extends CustomValueWithIntrinsics {
 }

package/dist/types/with-intrinsics.js

@@ -9,6 +9,9 @@ class CustomValueWithIntrinsics extends base_1.CustomValue {
     static addIntrinsic(key, fn) {
         this.intrinsics.set(key, fn);
     }
+    getIntrinsics() {
+        return this.constructor.intrinsics;
+    }
 }
 exports.CustomValueWithIntrinsics = CustomValueWithIntrinsics;
 class CustomObject extends CustomValueWithIntrinsics {

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

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

package/dist/utils/create-assign.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssign = void 0;
+const greyscript_core_1 = require("greyscript-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 greyscript_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

@@ -0,0 +1,5 @@
+import { ASTBase, ASTIdentifier } from 'greyscript-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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResolve = exports.createIdentifierResolve = void 0;
+const greyscript_core_1 = require("greyscript-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 greyscript_core_1.ASTMemberExpression) {
+        const memberExpr = item;
+        const path = (0, lookup_path_1.lookupPath)(memberExpr);
+        if (path.length > 0 &&
+            path[0].base instanceof greyscript_core_1.ASTIdentifier &&
+            hasOwnProperty.call(optResolveMap, path[0].base.name)) {
+            const OptResolve = optResolveMap[path[0].base.name];
+            const right = path[0].identifier;
+            if (path.length === 1) {
+                return new OptResolve(right, target);
+            }
+            const newBase = path[1];
+            newBase.base = right;
+            return new OptResolve(memberExpr, target);
+        }
+    }
+    return new resolve_1.Resolve(item, target);
+}
+exports.createResolve = createResolve;

package/dist/utils/get-super.d.ts

@@ -0,0 +1,3 @@
+import { CustomValue } from '../types/base';
+import { CustomMap } from '../types/map';
+export declare function getSuper(item: CustomValue): CustomMap;

package/dist/utils/get-super.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSuper = void 0;
+const map_1 = require("../types/map");
+function getSuper(item) {
+    var _a;
+    if (item instanceof map_1.CustomMap) {
+        return (_a = item.getIsa()) !== null && _a !== void 0 ? _a : new map_1.CustomMap(item.getIntrinsics());
+    }
+    return null;
+}
+exports.getSuper = getSuper;

package/dist/utils/lookup-path.d.ts

@@ -0,0 +1,2 @@
+import { ASTMemberExpression } from 'greyscript-core';
+export declare function lookupPath(item: ASTMemberExpression): ASTMemberExpression[];

package/dist/utils/lookup-path.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupPath = void 0;
+const greyscript_core_1 = require("greyscript-core");
+function lookupPath(item) {
+    const path = [item];
+    let current = item.base;
+    while (current instanceof greyscript_core_1.ASTMemberExpression) {
+        path.unshift(current);
+        current = current.base;
+    }
+    return path;
+}
+exports.lookupPath = lookupPath;

package/package.json

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