greybel-interpreter 3.0.4 → 3.1.1

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 {
@@ -107,20 +108,23 @@ class Resolve extends operation_1.Operation {
             switch (node.type) {
                 case miniscript_core_1.ASTType.MemberExpression: {
                     const memberExpr = node;
-                    yield this.buildProcessor(memberExpr.base, visit);
+                    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;
-                    yield this.buildProcessor(indexExpr.base, visit);
+                    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;
-                    yield this.buildProcessor(sliceExpr.base, visit);
+                    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);
@@ -149,15 +153,17 @@ 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 exitObserver = ctx.processState.createExitObserver();
             const maxIndex = this.path.count();
             const lastIndex = maxIndex - 1;
-            for (let index = 0; index < maxIndex; index++) {
-                if (ctx.isExit()) {
-                    return new ResolveResult(null, default_1.DefaultType.Void);
+            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) {
@@ -173,7 +179,7 @@ class Resolve extends operation_1.Operation {
                     if (!(handle instanceof ResolveNil)) {
                         if (handle instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
                             const customValueCtx = handle;
-                            handle = customValueCtx.get(traversedPath);
+                            handle = customValueCtx.get(traversedPath, ctx.contextTypeIntrinsics);
                         }
                         else {
                             throw new Error(`Unknown path ${traversedPath.toString()}.`);
@@ -187,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);
@@ -207,15 +214,17 @@ class Resolve extends operation_1.Operation {
                     }
                 }
             }
+            exitObserver.close();
             return new ResolveResult(traversedPath, handle);
         });
     }
     handle(ctx, result = null, autoCall = true) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (result === null) {
+                const exitObserver = ctx.processState.createExitObserver();
                 result = yield this.getResult(ctx);
-                if (ctx.isExit()) {
+                exitObserver.close();
+                if (exitObserver.occured()) {
                     return default_1.DefaultType.Void;
                 }
             }
@@ -228,17 +237,20 @@ class Resolve extends operation_1.Operation {
                 }
                 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) {
-                        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, customValueCtx.getIsa());
+                                return child.run(ctx.functionState.context, [], ctx);
                             }
-                            return superChild.run(customValueCtx, [], ctx);
+                            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);
                     }

package/dist/operations/while.js

@@ -35,12 +35,14 @@ class While extends operation_1.OperationBlock {
                 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;
                         }
@@ -48,13 +50,15 @@ class While extends operation_1.OperationBlock {
                         yield this.block.handle(whileCtx);
                         if (loopState.isBreak ||
                             whileCtx.functionState.isReturn ||
-                            ctx.isExit()) {
+                            exitObserver.occured()) {
+                            exitObserver.close();
                             resolve(default_1.DefaultType.Void);
                             return;
                         }
                         (0, set_immediate_1.setImmediate)(iteration);
                     }
                     catch (err) {
+                        exitObserver.close();
                         reject(err);
                     }
                 });

package/dist/types/base.d.ts

@@ -1,3 +1,4 @@
+import { ContextTypeIntrinsics } from '../context/types';
 export declare abstract class CustomValue {
     abstract value: any;
     abstract getCustomType(): string;
@@ -7,5 +8,6 @@ export declare abstract class CustomValue {
     abstract toString(): string;
     abstract toTruthy(): boolean;
     abstract fork(): CustomValue;
-    abstract instanceOf(value: CustomValue): boolean;
+    abstract instanceOf(value: CustomValue, typeIntrinsics: ContextTypeIntrinsics): boolean;
+    abstract hash(recursionDepth?: number): number;
 }

package/dist/types/function.d.ts

@@ -1,10 +1,10 @@
 import { OperationContext } from '../context';
+import { ContextTypeIntrinsics } from '../context/types';
 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>>;
+    (ctx: OperationContext, self: CustomValue, args: Map<string, CustomValue>): Promise<NonNullable<CustomValue>>;
 }
 export declare const DEFAULT_FUNCTION_NAME = "anonymous";
 export declare const SELF_NAMESPACE = "self";
@@ -21,18 +21,24 @@ export declare class CustomFunction extends CustomValue {
     readonly name: string;
     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;
-    constructor(scope: OperationContext, name: string, callback: Callback);
+    constructor(scope: OperationContext, name: string, callback: Callback, argumentDefs?: Array<Argument>, assignOuter?: boolean);
     addArgument(name: string, defaultValue?: Operation | CustomValue): CustomFunction;
-    fork(): CustomValue;
+    fork(): CustomFunction;
+    forkAs(name: string): CustomFunction;
     getCustomType(): string;
     toNumber(): number;
     toInt(): number;
     toJSON(): string;
     toString(): string;
     toTruthy(): boolean;
-    instanceOf(v: CustomValue): boolean;
-    run(self: CustomValue, args: Array<CustomValue>, callContext: OperationContext, next?: CustomMap): Promise<CustomValue>;
+    instanceOf(v: CustomValue, typeIntrinsics: ContextTypeIntrinsics): boolean;
+    setNextContext(value: CustomValue): this;
+    getNextContext(): CustomValue;
+    run(self: CustomValue, args: Array<CustomValue>, callContext: OperationContext): Promise<CustomValue>;
+    hash(): number;
 }

package/dist/types/function.js

@@ -14,10 +14,10 @@ const context_1 = require("../context");
 const literal_1 = require("../operations/literal");
 const operation_1 = require("../operations/operation");
 const reference_1 = require("../operations/reference");
+const hash_1 = require("../utils/hash");
 const object_value_1 = require("../utils/object-value");
 const base_1 = require("./base");
 const default_1 = require("./default");
-const map_1 = require("./map");
 const nil_1 = require("./nil");
 const string_1 = require("./string");
 exports.DEFAULT_FUNCTION_NAME = 'anonymous';
@@ -51,19 +51,24 @@ class CustomFunction extends base_1.CustomValue {
     static createExternalWithSelf(name, callback) {
         return new CustomFunction(null, name, callback).addArgument(exports.SELF_NAMESPACE);
     }
-    constructor(scope, name, callback) {
+    constructor(scope, name, callback, argumentDefs = [], assignOuter = false) {
         super();
         this.scope = scope;
         this.name = name;
         this.value = callback;
-        this.argumentDefs = [];
+        this.argumentDefs = argumentDefs;
+        this.assignOuter = assignOuter;
+        this._nextContext = null;
     }
     addArgument(name, defaultValue = default_1.DefaultType.Void) {
         this.argumentDefs.push(new Argument(name, defaultValue));
         return this;
     }
     fork() {
-        return new CustomFunction(this.scope, this.name, this.value);
+        return new CustomFunction(this.scope, this.name, this.value, this.argumentDefs);
+    }
+    forkAs(name) {
+        return new CustomFunction(this.scope, name, this.value, this.argumentDefs);
     }
     getCustomType() {
         return 'function';
@@ -80,7 +85,8 @@ class CustomFunction extends base_1.CustomValue {
     toString() {
         let refs = 1;
         const args = this.argumentDefs.map((item) => {
-            if (item.defaultValue instanceof literal_1.Literal) {
+            if (item.defaultValue instanceof literal_1.Literal ||
+                item.defaultValue instanceof reference_1.Reference) {
                 const value = item.defaultValue.value;
                 if (value instanceof nil_1.CustomNil) {
                     return item.name;
@@ -100,46 +106,54 @@ class CustomFunction extends base_1.CustomValue {
     toTruthy() {
         return true;
     }
-    instanceOf(v) {
-        return v.value === CustomFunction.intrinsics;
+    instanceOf(v, typeIntrinsics) {
+        var _a;
+        return v.value === ((_a = typeIntrinsics.function) !== null && _a !== void 0 ? _a : CustomFunction.intrinsics);
+    }
+    setNextContext(value) {
+        this._nextContext = value;
+        return this;
     }
-    run(self, args, callContext, next) {
-        var _a, _b;
+    getNextContext() {
+        return this._nextContext;
+    }
+    run(self, args, callContext) {
+        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
+                state: context_1.ContextState.Default,
+                ignoreOuter: !this.assignOuter,
+                processState: callContext.processState
             });
             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)));
+                argMap.set(item.name, (_d = args[argIndex - selfParam]) !== null && _d !== void 0 ? _d : (yield item.defaultValue.handle(fnCtx)));
             }
-            if (!isSelfNull) {
-                argMap.set(exports.SELF_NAMESPACE, self);
+            const selfValue = hasSelf ? self : selfWithinArgs;
+            if (selfValue) {
+                argMap.set(exports.SELF_NAMESPACE, selfValue);
             }
-            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);
+            const result = yield this.value(fnCtx !== null && fnCtx !== void 0 ? fnCtx : callContext, selfValue, argMap);
+            this._nextContext = null;
+            return result;
         });
     }
+    hash() {
+        return (0, hash_1.getStringHashCode)(this.toString());
+    }
 }
 CustomFunction.intrinsics = new object_value_1.ObjectValue();
 exports.CustomFunction = CustomFunction;

package/dist/types/list.d.ts

@@ -1,7 +1,8 @@
+import { ContextTypeIntrinsics } from '../context/types';
 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;
@@ -20,12 +21,14 @@ export declare class CustomList extends CustomObject {
     toNumber(): number;
     toInt(): number;
     toTruthy(): boolean;
-    instanceOf(v: CustomValue): boolean;
+    instanceOf(v: CustomValue, typeIntrinsics: ContextTypeIntrinsics): boolean;
     slice(a: CustomValue, b: CustomValue): CustomList;
     extend(list: CustomList | Array<CustomValue>): CustomList;
     [Symbol.iterator](): CustomListIterator;
     getItemIndex(index: number): number;
     has(path: Path<CustomValue> | CustomValue): boolean;
     set(path: Path<CustomValue> | CustomValue, newValue: CustomValue): void;
-    get(path: Path<CustomValue> | CustomValue): CustomValue;
+    get(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValue;
+    getWithOrigin(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValueWithIntrinsicsResult;
+    hash(recursionDepth?: number): number;
 }

package/dist/types/list.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomList = exports.CustomListIterator = void 0;
+const hash_1 = require("../utils/hash");
 const object_value_1 = require("../utils/object-value");
 const path_1 = require("../utils/path");
 const base_1 = require("./base");
@@ -61,8 +62,9 @@ class CustomList extends with_intrinsics_1.CustomObject {
     toTruthy() {
         return this.value.length > 0;
     }
-    instanceOf(v) {
-        return v.value === CustomList.intrinsics;
+    instanceOf(v, typeIntrinsics) {
+        var _a;
+        return v.value === ((_a = typeIntrinsics.list) !== null && _a !== void 0 ? _a : CustomList.intrinsics);
     }
     slice(a, b) {
         return new CustomList(this.value.slice(a.toNumber(), b.toNumber()));
@@ -130,9 +132,10 @@ class CustomList extends with_intrinsics_1.CustomObject {
         }
         throw new Error(`Index is not a number.`);
     }
-    get(path) {
+    get(path, typeIntrinsics) {
+        var _a;
         if (path instanceof base_1.CustomValue) {
-            return this.get(new path_1.Path([path]));
+            return this.get(new path_1.Path([path]), typeIntrinsics);
         }
         const traversalPath = path.clone();
         const current = traversalPath.next();
@@ -142,7 +145,7 @@ class CustomList extends with_intrinsics_1.CustomObject {
                 const sub = this.value[currentIndex];
                 if (traversalPath.count() > 0) {
                     if (sub instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
-                        return sub.get(traversalPath);
+                        return sub.get(traversalPath, typeIntrinsics);
                     }
                 }
                 else if (traversalPath.count() === 0) {
@@ -151,11 +154,27 @@ class CustomList extends with_intrinsics_1.CustomObject {
             }
             throw new Error(`Index error (list index ${currentIndex} out of range).`);
         }
-        else if (path.count() === 1 && CustomList.getIntrinsics().has(current)) {
-            return CustomList.getIntrinsics().get(current);
+        const intrinsics = (_a = typeIntrinsics.list) !== null && _a !== void 0 ? _a : CustomList.getIntrinsics();
+        if (path.count() === 1 && intrinsics.has(current)) {
+            return intrinsics.get(current);
         }
         throw new Error(`Unknown path in list ${path.toString()}.`);
     }
+    getWithOrigin(path, typeIntrinsics) {
+        return {
+            value: this.get(path, typeIntrinsics),
+            origin: null
+        };
+    }
+    hash(recursionDepth = 0) {
+        let result = (0, hash_1.getHashCode)(this.value.length);
+        if (recursionDepth > 16)
+            return result;
+        this.value.forEach((value) => {
+            result = (0, hash_1.rotateBits)(result) ^ value.hash(recursionDepth + 1);
+        });
+        return result;
+    }
 }
 CustomList.intrinsics = new object_value_1.ObjectValue();
 exports.CustomList = CustomList;

package/dist/types/map.d.ts

@@ -1,8 +1,9 @@
+import { ContextTypeIntrinsics } from '../context/types';
 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;
@@ -26,12 +27,14 @@ export declare class CustomMap extends CustomObject {
     toNumber(): number;
     toInt(): number;
     toTruthy(): boolean;
-    instanceOf(v: CustomValue): boolean;
+    instanceOf(v: CustomValue, typeIntrinsics: ContextTypeIntrinsics): boolean;
     [Symbol.iterator](): CustomMapIterator;
     extend(map: CustomMap | ObjectValue): CustomMap;
     has(path: Path<CustomValue> | CustomValue): boolean;
     set(path: Path<CustomValue> | CustomValue, newValue: CustomValue): void;
-    get(path: Path<CustomValue> | CustomValue): CustomValue;
+    get(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValue;
+    getWithOrigin(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValueWithIntrinsicsResult;
     createInstance(): CustomMap;
     getIsa(): CustomMap | null;
+    hash(recursionDepth?: number): number;
 }

package/dist/types/map.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomMap = exports.CustomMapIterator = exports.CUSTOM_MAP_MAX_DEPTH_VALUE = exports.CUSTOM_MAP_MAX_DEPTH = exports.ISA_PROPERTY = exports.CLASS_ID_PROPERTY = void 0;
+const hash_1 = require("../utils/hash");
 const object_value_1 = require("../utils/object-value");
 const path_1 = require("../utils/path");
 const base_1 = require("./base");
@@ -81,7 +82,8 @@ class CustomMap extends with_intrinsics_1.CustomObject {
     toTruthy() {
         return this.value.size > 0;
     }
-    instanceOf(v) {
+    instanceOf(v, typeIntrinsics) {
+        var _a;
         if (v instanceof CustomMap) {
             let current = this;
             while ((current = current.getIsa())) {
@@ -89,7 +91,7 @@ class CustomMap extends with_intrinsics_1.CustomObject {
                     return true;
                 }
             }
-            return v.value === CustomMap.intrinsics;
+            return v.value === ((_a = typeIntrinsics.map) !== null && _a !== void 0 ? _a : CustomMap.getIntrinsics());
         }
         return false;
     }
@@ -142,9 +144,10 @@ class CustomMap extends with_intrinsics_1.CustomObject {
         }
         this.value.set(last, newValue);
     }
-    get(path) {
+    get(path, typeIntrinsics) {
+        var _a;
         if (path instanceof base_1.CustomValue) {
-            return this.get(new path_1.Path([path]));
+            return this.get(new path_1.Path([path]), typeIntrinsics);
         }
         const traversalPath = path.clone();
         const current = traversalPath.next();
@@ -154,7 +157,7 @@ class CustomMap extends with_intrinsics_1.CustomObject {
                 const sub = this.value.get(current);
                 if (traversalPath.count() > 0) {
                     if (sub instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
-                        return sub.get(traversalPath);
+                        return sub.get(traversalPath, typeIntrinsics);
                     }
                 }
                 else if (traversalPath.count() === 0) {
@@ -162,10 +165,53 @@ class CustomMap extends with_intrinsics_1.CustomObject {
                 }
             }
             else if (isa === null || isa === void 0 ? void 0 : isa.has(current)) {
-                return isa.get(current);
+                return isa.get(current, typeIntrinsics);
             }
-            else if (path.count() === 1 && CustomMap.getIntrinsics().has(current)) {
-                return CustomMap.getIntrinsics().get(current);
+            const intrinsics = (_a = typeIntrinsics.map) !== null && _a !== void 0 ? _a : CustomMap.getIntrinsics();
+            if (traversalPath.count() === 0 && intrinsics.has(current)) {
+                return intrinsics.get(current);
+            }
+        }
+        throw new Error(`Unknown path in map ${path.toString()}.`);
+    }
+    getWithOrigin(path, typeIntrinsics) {
+        var _a;
+        if (path instanceof base_1.CustomValue) {
+            return this.getWithOrigin(new path_1.Path([path]), typeIntrinsics);
+        }
+        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, typeIntrinsics);
+                    }
+                    if (sub instanceof with_intrinsics_1.CustomValueWithIntrinsics) {
+                        return {
+                            value: sub.get(traversalPath, typeIntrinsics),
+                            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, typeIntrinsics);
+            }
+            const intrinsics = (_a = typeIntrinsics.map) !== null && _a !== void 0 ? _a : CustomMap.getIntrinsics();
+            if (traversalPath.count() === 0 && intrinsics.has(current)) {
+                return {
+                    value: intrinsics.get(current),
+                    origin: null
+                };
             }
         }
         throw new Error(`Unknown path in map ${path.toString()}.`);
@@ -180,6 +226,16 @@ class CustomMap extends with_intrinsics_1.CustomObject {
         const isa = this.value.get(exports.ISA_PROPERTY);
         return isa instanceof CustomMap ? isa : null;
     }
+    hash(recursionDepth = 0) {
+        let result = (0, hash_1.getHashCode)(this.value.size);
+        if (recursionDepth > 16)
+            return result;
+        this.value.forEach((value, key) => {
+            result ^= key.hash(recursionDepth + 1);
+            result ^= value.hash(recursionDepth + 1);
+        });
+        return result;
+    }
 }
 CustomMap.intrinsics = new object_value_1.ObjectValue();
 exports.CustomMap = CustomMap;

package/dist/types/nil.d.ts

@@ -9,5 +9,6 @@ export declare class CustomNil extends CustomValue {
     toInt(): number;
     toTruthy(): boolean;
     instanceOf(v: CustomValue): boolean;
+    hash(): number;
 }
 export declare const Void: CustomNil;

package/dist/types/nil.js

@@ -31,6 +31,9 @@ class CustomNil extends base_1.CustomValue {
     instanceOf(v) {
         return v instanceof CustomNil;
     }
+    hash() {
+        return -1;
+    }
 }
 exports.CustomNil = CustomNil;
 exports.Void = new CustomNil();

package/dist/types/number.d.ts

@@ -1,7 +1,8 @@
+import { ContextTypeIntrinsics } from '../context/types';
 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>;
@@ -17,11 +18,13 @@ export declare class CustomNumber extends CustomValueWithIntrinsics {
     toInt(): number;
     toNumber(): number;
     toTruthy(): boolean;
-    instanceOf(v: CustomValue): boolean;
+    instanceOf(v: CustomValue, typeIntrinsics: ContextTypeIntrinsics): boolean;
     [Symbol.iterator](): CustomNumberIterator;
     has(_path: Path<CustomValue> | CustomValue): boolean;
     set(_path: Path<CustomValue> | CustomValue, _newValue: CustomValue): void;
-    get(path: Path<CustomValue> | CustomValue): CustomValue;
+    get(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValue;
+    getWithOrigin(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValueWithIntrinsicsResult;
+    hash(): number;
 }
 export declare const NegativeOne: CustomNumber;
 export declare const PositiveOne: CustomNumber;