greybel-interpreter 3.0.4 → 3.1.1

package/dist/types/number.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Zero = exports.PositiveOne = exports.NegativeOne = exports.CustomNumber = exports.CustomNumberIterator = 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");
-const nil_1 = require("./nil");
 const with_intrinsics_1 = require("./with-intrinsics");
 class CustomNumberIterator {
     constructor() {
@@ -44,8 +44,9 @@ class CustomNumber extends with_intrinsics_1.CustomValueWithIntrinsics {
     toTruthy() {
         return !!this.value;
     }
-    instanceOf(v) {
-        return v.value === CustomNumber.intrinsics;
+    instanceOf(v, typeIntrinsics) {
+        var _a;
+        return v.value === ((_a = typeIntrinsics.number) !== null && _a !== void 0 ? _a : CustomNumber.intrinsics);
     }
     [Symbol.iterator]() {
         return new CustomNumberIterator();
@@ -56,16 +57,27 @@ class CustomNumber extends with_intrinsics_1.CustomValueWithIntrinsics {
     set(_path, _newValue) {
         throw new Error('Mutable operations are not allowed on 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();
-        if (path.count() === 1 && CustomNumber.getIntrinsics().has(current)) {
-            return CustomNumber.intrinsics.get(current);
+        const intrinsics = (_a = typeIntrinsics.number) !== null && _a !== void 0 ? _a : CustomNumber.getIntrinsics();
+        if (traversalPath.count() === 0 && intrinsics.has(current)) {
+            return intrinsics.get(current);
         }
-        return nil_1.Void;
+        throw new Error(`Unknown path in number ${path.toString()}.`);
+    }
+    getWithOrigin(path, typeIntrinsics) {
+        return {
+            value: this.get(path, typeIntrinsics),
+            origin: null
+        };
+    }
+    hash() {
+        return (0, hash_1.getHashCode)(this.value);
     }
 }
 CustomNumber.intrinsics = new object_value_1.ObjectValue();

package/dist/types/string.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 CustomStringIterator implements Iterator<CustomValue> {
     value: string;
     index: number;
@@ -23,11 +24,13 @@ export declare class CustomString extends CustomValueWithIntrinsics {
     toNumber(): number;
     toInt(): number;
     toTruthy(): boolean;
-    instanceOf(v: CustomValue): boolean;
+    instanceOf(v: CustomValue, typeIntrinsics: ContextTypeIntrinsics): boolean;
     slice(a: CustomValue, b: CustomValue): CustomString;
     [Symbol.iterator](): CustomStringIterator;
     getCharIndex(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(): number;
 }

package/dist/types/string.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomString = exports.CustomStringIterator = 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");
-const default_1 = require("./default");
 const number_1 = require("./number");
 const with_intrinsics_1 = require("./with-intrinsics");
 class CustomStringIterator {
@@ -72,8 +72,9 @@ class CustomString extends with_intrinsics_1.CustomValueWithIntrinsics {
     toTruthy() {
         return this.value.length > 0;
     }
-    instanceOf(v) {
-        return v.value === CustomString.intrinsics;
+    instanceOf(v, typeIntrinsics) {
+        var _a;
+        return v.value === ((_a = typeIntrinsics.string) !== null && _a !== void 0 ? _a : CustomString.intrinsics);
     }
     slice(a, b) {
         return new CustomString(this.value.slice(a.toNumber(), b.toNumber()));
@@ -99,9 +100,10 @@ class CustomString extends with_intrinsics_1.CustomValueWithIntrinsics {
     set(_path, _newValue) {
         throw new Error('Mutable operations are not allowed on a string.');
     }
-    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();
@@ -113,11 +115,20 @@ class CustomString extends with_intrinsics_1.CustomValueWithIntrinsics {
             }
             throw new Error(`Index error (string index ${currentIndex} out of range).`);
         }
-        else if (path.count() === 1 &&
-            CustomString.getIntrinsics().has(current)) {
-            return CustomString.intrinsics.get(current);
+        const intrinsics = (_a = typeIntrinsics.string) !== null && _a !== void 0 ? _a : CustomString.getIntrinsics();
+        if (traversalPath.count() === 0 && intrinsics.has(current)) {
+            return intrinsics.get(current);
         }
-        return default_1.DefaultType.Void;
+        throw new Error(`Unknown path in string ${path.toString()}.`);
+    }
+    getWithOrigin(path, typeIntrinsics) {
+        return {
+            value: this.get(path, typeIntrinsics),
+            origin: null
+        };
+    }
+    hash() {
+        return (0, hash_1.getStringHashCode)(this.value);
     }
 }
 CustomString.intrinsics = new object_value_1.ObjectValue();

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

@@ -1,17 +1,25 @@
+import { ContextTypeIntrinsics } from '../context/types';
 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 get(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValue;
+    abstract getWithOrigin(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValueWithIntrinsicsResult;
     abstract [Symbol.iterator](): Iterator<CustomValue> & {
         index: number;
     };
     static readonly intrinsics: ObjectValue;
     static getIntrinsics(): ObjectValue;
     static addIntrinsic(key: CustomValue, fn: CustomFunction): void;
+    static clearIntrinsics(): void;
+    getIntrinsics(): ObjectValue;
 }
 export declare abstract class CustomObject extends CustomValueWithIntrinsics {
 }

package/dist/types/with-intrinsics.js

@@ -9,6 +9,12 @@ class CustomValueWithIntrinsics extends base_1.CustomValue {
     static addIntrinsic(key, fn) {
         this.intrinsics.set(key, fn);
     }
+    static clearIntrinsics() {
+        this.intrinsics.clear();
+    }
+    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 'miniscript-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 miniscript_core_1 = require("miniscript-core");
+const assign_1 = require("../operations/assign");
+const assign_globals_1 = require("../operations/assign-globals");
+const assign_locals_1 = require("../operations/assign-locals");
+const assign_outer_1 = require("../operations/assign-outer");
+const assign_self_1 = require("../operations/assign-self");
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const optAssignMap = {
+    self: assign_self_1.AssignSelf,
+    globals: assign_globals_1.AssignGlobals,
+    locals: assign_locals_1.AssignLocals,
+    outer: assign_outer_1.AssignOuter
+};
+function createAssign(item, target) {
+    if (item.variable instanceof miniscript_core_1.ASTIdentifier &&
+        hasOwnProperty.call(optAssignMap, item.variable.name)) {
+        const OptAssign = optAssignMap[item.variable.name];
+        return new OptAssign(item, target);
+    }
+    return new assign_1.Assign(item, target);
+}
+exports.createAssign = createAssign;

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

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

package/dist/utils/create-resolve.js

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

package/dist/utils/deep-equal.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deepEqual = void 0;
+const list_1 = require("../types/list");
+const map_1 = require("../types/map");
 const with_intrinsics_1 = require("../types/with-intrinsics");
 function equalInner(a, b, maxDepth, depth = 0) {
     if (maxDepth <= depth)
@@ -10,7 +12,7 @@ function equalInner(a, b, maxDepth, depth = 0) {
     if (a && b && a instanceof with_intrinsics_1.CustomObject && b instanceof with_intrinsics_1.CustomObject) {
         if (a.constructor !== b.constructor)
             return false;
-        if (Array.isArray(a.value)) {
+        if (a instanceof list_1.CustomList) {
             const length = a.value.length;
             if (length !== b.value.length)
                 return false;
@@ -19,12 +21,15 @@ function equalInner(a, b, maxDepth, depth = 0) {
                     return false;
             return true;
         }
-        if (a.value instanceof Map) {
+        if (a instanceof map_1.CustomMap) {
             if (a.value.size !== b.value.size)
                 return false;
-            for (const i of a.value.keys())
-                if (!b.has(i) || !equalInner(a.get(i), b.get(i), maxDepth, depth + 1))
+            for (const i of a.value.keys()) {
+                if (!b.value.has(i) ||
+                    !equalInner(a.value.get(i), b.value.get(i), maxDepth, depth + 1)) {
                     return false;
+                }
+            }
             return true;
         }
         return false;

package/dist/utils/error.d.ts

@@ -8,7 +8,7 @@ export declare class RuntimeError extends Error {
     target: string;
     stackTrace: Operation[];
     source?: Error;
-    constructor(message: string, context: RuntimeContext, source?: Error);
+    constructor(message: string, context?: RuntimeContext, source?: Error);
     private createTrace;
 }
 interface PrepareContext {

package/dist/utils/error.js

@@ -5,8 +5,8 @@ class RuntimeError extends Error {
     constructor(message, context, source) {
         var _a;
         super(message);
-        this.target = context.target;
-        this.stackTrace = (_a = context.stackTrace) !== null && _a !== void 0 ? _a : [];
+        this.target = context === null || context === void 0 ? void 0 : context.target;
+        this.stackTrace = (_a = context === null || context === void 0 ? void 0 : context.stackTrace) !== null && _a !== void 0 ? _a : [];
         this.stack = this.createTrace();
         this.source = source;
     }

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();
+    }
+    return null;
+}
+exports.getSuper = getSuper;

package/dist/utils/hash.d.ts

@@ -0,0 +1,3 @@
+export declare function rotateBits(n: number): number;
+export declare function getHashCode(value: number, offset?: number): number;
+export declare const getStringHashCode: (value: string) => number;

package/dist/utils/hash.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStringHashCode = exports.getHashCode = exports.rotateBits = void 0;
+const lru_cache_1 = require("lru-cache");
+function rotateBits(n) {
+    return (n >> 1) | (n << 31);
+}
+exports.rotateBits = rotateBits;
+function getHashCode(value, offset = 0) {
+    let unsigned = value >>> 0;
+    unsigned = ((unsigned >> 16) ^ unsigned) * 0x45d9f3b;
+    unsigned = ((unsigned >> 16) ^ unsigned) * 0x45d9f3b;
+    unsigned = (unsigned >> 16) ^ unsigned;
+    return ((offset << 5) - offset + unsigned) | 0;
+}
+exports.getHashCode = getHashCode;
+exports.getStringHashCode = (function () {
+    const cache = new lru_cache_1.LRUCache({
+        ttl: 1000 * 60 * 5,
+        max: 500
+    });
+    const generateHash = (value) => {
+        let hash = 0;
+        for (let i = 0; i < value.length; i++) {
+            const chr = value.charCodeAt(i);
+            hash = getHashCode(chr, hash);
+        }
+        return hash;
+    };
+    return (value) => {
+        if (value.length === 0) {
+            return 0;
+        }
+        if (cache.has(value)) {
+            return cache.get(value);
+        }
+        const hash = generateHash(value);
+        cache.set(value, hash);
+        return hash;
+    };
+})();

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

@@ -0,0 +1,3 @@
+import { ASTIndexExpression, ASTMemberExpression, ASTSliceExpression } from 'miniscript-core';
+export type PathItem = ASTMemberExpression | ASTIndexExpression | ASTSliceExpression;
+export declare function lookupPath(item: PathItem): PathItem[];

package/dist/utils/lookup-path.js

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

package/dist/utils/next-tick.d.ts

@@ -0,0 +1 @@
+export declare const nextTick: () => Promise<void>;

package/dist/utils/next-tick.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextTick = void 0;
+const set_immediate_1 = require("./set-immediate");
+const nextTick = () => {
+    return new Promise((resolve) => {
+        (0, set_immediate_1.setImmediate)(resolve);
+    });
+};
+exports.nextTick = nextTick;

package/dist/utils/object-value.d.ts

@@ -1,8 +1,18 @@
 import { CustomValue } from '../types/base';
-export declare class ObjectValue extends Map<CustomValue, CustomValue> {
+export type ObjectValueKeyPair = [CustomValue, CustomValue];
+export declare class ObjectValue {
+    private data;
+    constructor(entries?: ObjectValue | ObjectValueKeyPair[] | null);
     get(mapKey: CustomValue): CustomValue;
     has(mapKey: CustomValue): boolean;
     set(mapKey: CustomValue, mapValue: CustomValue): this;
     delete(mapKey: CustomValue): boolean;
+    values(): CustomValue[];
+    keys(): CustomValue[];
+    entries(): ObjectValueKeyPair[];
+    get size(): number;
+    forEach(callback: (value: CustomValue, key: CustomValue, map: ObjectValue) => any): void;
+    fork(): ObjectValue;
     extend(objVal: ObjectValue): this;
+    clear(): void;
 }

package/dist/utils/object-value.js

@@ -2,48 +2,75 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectValue = void 0;
 const nil_1 = require("../types/nil");
-const deep_equal_1 = require("./deep-equal");
-class ObjectValue extends Map {
-    get(mapKey) {
-        for (const [key, value] of this.entries()) {
-            if ((0, deep_equal_1.deepEqual)(key, mapKey)) {
-                return value;
+class ObjectValue {
+    constructor(entries) {
+        if (entries == null) {
+            this.data = new Map();
+        }
+        else if (entries instanceof ObjectValue) {
+            this.data = new Map(entries.data);
+        }
+        else if (Array.isArray(entries)) {
+            this.data = new Map();
+            for (const [key, value] of entries) {
+                this.set(key, value);
             }
         }
-        return nil_1.Void;
+        if (this.data == null) {
+            throw new Error('Unknown entries type.');
+        }
+    }
+    get(mapKey) {
+        const hash = mapKey.hash();
+        if (!this.data.has(hash))
+            return nil_1.Void;
+        return this.data.get(hash)[1];
     }
     has(mapKey) {
-        for (const key of this.keys()) {
-            if ((0, deep_equal_1.deepEqual)(key, mapKey)) {
-                return true;
-            }
-        }
-        return false;
+        const hash = mapKey.hash();
+        return this.data.has(hash);
     }
     set(mapKey, mapValue) {
-        for (const key of this.keys()) {
-            if ((0, deep_equal_1.deepEqual)(key, mapKey)) {
-                super.set(key, mapValue);
-                return;
-            }
-        }
-        super.set(mapKey, mapValue);
+        const hash = mapKey.hash();
+        this.data.set(hash, [mapKey, mapValue]);
         return this;
     }
     delete(mapKey) {
-        for (const key of this.keys()) {
-            if ((0, deep_equal_1.deepEqual)(key, mapKey)) {
-                super.delete(key);
-                return true;
-            }
+        const hash = mapKey.hash();
+        return this.data.delete(hash);
+    }
+    values() {
+        return [...this.data.values()].map(([_, v]) => v);
+    }
+    keys() {
+        return [...this.data.values()].map(([k]) => k);
+    }
+    entries() {
+        return [...this.data.values()];
+    }
+    get size() {
+        return this.data.size;
+    }
+    forEach(callback) {
+        for (const [key, value] of this.data.values()) {
+            callback(value, key, this);
         }
-        return false;
+    }
+    fork() {
+        const newObject = new ObjectValue();
+        for (const [key, value] of this.entries()) {
+            newObject.set(key.fork(), value.fork());
+        }
+        return newObject;
     }
     extend(objVal) {
-        for (const [key, value] of objVal) {
+        for (const [key, value] of objVal.entries()) {
             this.set(key, value);
         }
         return this;
     }
+    clear() {
+        this.data.clear();
+    }
 }
 exports.ObjectValue = ObjectValue;

package/dist/utils/uuid.d.ts

@@ -0,0 +1 @@
+export declare const uuid: () => string;

package/dist/utils/uuid.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid = void 0;
+// Source: https://gist.github.com/alemures/ba4cd1b37a4b11346d7f54f05c826d24
+function createUUIDFactory() {
+    const lut = [];
+    for (let i = 0; i < 256; i++)
+        lut[i] = (i < 16 ? '0' : '') + i.toString(16);
+    return function () {
+        const d0 = (Math.random() * 0xffffffff) | 0;
+        const d1 = (Math.random() * 0xffffffff) | 0;
+        const d2 = (Math.random() * 0xffffffff) | 0;
+        const d3 = (Math.random() * 0xffffffff) | 0;
+        return (lut[d0 & 0xff] +
+            lut[(d0 >> 8) & 0xff] +
+            lut[(d0 >> 16) & 0xff] +
+            lut[(d0 >> 24) & 0xff] +
+            '-' +
+            lut[d1 & 0xff] +
+            lut[(d1 >> 8) & 0xff] +
+            '-' +
+            lut[((d1 >> 16) & 0x0f) | 0x40] +
+            lut[(d1 >> 24) & 0xff] +
+            '-' +
+            lut[(d2 & 0x3f) | 0x80] +
+            lut[(d2 >> 8) & 0xff] +
+            '-' +
+            lut[(d2 >> 16) & 0xff] +
+            lut[(d2 >> 24) & 0xff] +
+            lut[d3 & 0xff] +
+            lut[(d3 >> 8) & 0xff] +
+            lut[(d3 >> 16) & 0xff] +
+            lut[(d3 >> 24) & 0xff]);
+    };
+}
+exports.uuid = createUUIDFactory();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greybel-interpreter",
-    "version": "3.0.4",
+    "version": "3.1.1",
     "description": "Interpreter",
     "main": "dist/index",
     "typings": "dist/index",
@@ -48,7 +48,8 @@
         "typescript": "^5.0.4"
     },
     "dependencies": {
-        "greybel-core": "^1.0.2"
+        "lru-cache": "^10.0.1",
+        "greybel-core": "^1.1.0"
     },
     "keywords": [
         "miniscript"