@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/IR/IRNodes/IRRecursive.d.ts

@@ -0,0 +1,29 @@
+import { IRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+import { IRTerm } from "../IRTerm.js";
+import { IRParentTerm } from "../utils/isIRParentTerm.js";
+import { BaseIRMetadata } from "./BaseIRMetadata.js";
+export interface IRRecursiveMetadata extends BaseIRMetadata {
+}
+export declare class IRRecursive {
+    static get kind(): IRNodeKind.Recursive;
+    get kind(): IRNodeKind.Recursive;
+    static get tag(): Uint8Array;
+    readonly arity: number;
+    constructor(body: IRTerm, func_name?: string | undefined, _unsafeHash?: IRHash);
+    private _body;
+    get body(): IRTerm;
+    set body(newBody: IRTerm);
+    private _hash;
+    get hash(): IRHash;
+    isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    readonly meta: IRRecursiveMetadata;
+    get name(): string | undefined;
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRTerm | undefined);
+    clone(): IRRecursive;
+    toJSON(): any;
+    toJson(): any;
+}

package/dist/IR/IRNodes/IRRecursive.js

@@ -0,0 +1,90 @@
+import { BasePlutsError } from "../../utils/BasePlutsError.js";
+import { isIRHash, hashIrData } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+import { concatUint8Arr } from "../utils/concatUint8Arr.js";
+import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
+import { isIRParentTerm } from "../utils/isIRParentTerm.js";
+import { isIRTerm } from "../utils/isIRTerm.js";
+export class IRRecursive {
+    static get kind() { return IRNodeKind.Recursive; }
+    get kind() { return IRRecursive.kind; }
+    static get tag() { return new Uint8Array([IRRecursive.kind]); }
+    arity;
+    constructor(body, func_name, _unsafeHash) {
+        if (!isIRTerm(body))
+            throw new Error("IRRecursive body argument was not an IRTerm");
+        Object.defineProperties(this, {
+            arity: {
+                value: 1,
+                writable: false,
+                enumerable: true,
+                configurable: false
+            },
+            meta: {
+                value: {
+                    name: typeof func_name === "string" ? func_name : (void 0)
+                },
+                writable: true,
+                enumerable: true,
+                configurable: false
+            }
+        });
+        this._body = body;
+        this._body.parent = this;
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+        this._parent = undefined;
+    }
+    _body;
+    get body() { return this._body; }
+    set body(newBody) {
+        if (!isIRTerm(newBody)) {
+            throw new BasePlutsError("invalid IRTerm to be a function body");
+        }
+        if (!shallowEqualIRTermHash(this._body, newBody))
+            this.markHashAsInvalid();
+        // keep the parent reference in the old child, useful for compilation
+        // _body.parent = undefined;
+        this._body = newBody;
+        this._body.parent = this;
+    }
+    _hash;
+    get hash() {
+        if (!isIRHash(this._hash)) {
+            this._hash = hashIrData(concatUint8Arr(IRRecursive.tag, 
+            // positiveIntAsBytes( this.arity ),
+            this._body.hash));
+        }
+        return this._hash;
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    meta;
+    get name() { return this.meta.name; }
+    ;
+    _parent;
+    get parent() { return this._parent; }
+    set parent(newParent) {
+        if (!( // assert
+        // new parent value is different than current
+        this._parent !== newParent && (
+        // and the new parent value is valid
+        newParent === undefined ||
+            isIRParentTerm(newParent))))
+            return;
+        this._parent = newParent;
+    }
+    clone() {
+        return new IRRecursive(this._body.clone(), this.meta.name, this.isHashPresent() ? this.hash : undefined);
+    }
+    toJSON() { return this.toJson(); }
+    toJson() {
+        return {
+            type: "IRRecursive",
+            arity: this.arity,
+            body: this._body.toJson()
+        };
+    }
+}

package/dist/IR/IRNodes/IRSelfCall.d.ts

@@ -0,0 +1,46 @@
+import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
+import { ToJson } from "../../utils/ToJson.js";
+import { IHash } from "../interfaces/IHash.js";
+import { IIRParent } from "../interfaces/IIRParent.js";
+import { IRParentTerm } from "../utils/isIRParentTerm.js";
+import { BaseIRMetadata } from "./BaseIRMetadata.js";
+import { IRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+import { IRRecursive } from "./IRRecursive.js";
+export interface IRSelfCallMetadata extends BaseIRMetadata {
+}
+export declare class IRSelfCall implements Cloneable<IRSelfCall>, IHash, IIRParent, ToJson {
+    private _hash;
+    get hash(): IRHash;
+    /**
+     * called inside the dbn setter
+     */
+    markHashAsInvalid(): void;
+    isHashPresent(): true;
+    private _dbn;
+    /**
+     * the IR DeBruijn index is not necessarly the same of the UPLC
+     * ( more ofthen than not it won't be the same )
+     *
+     * this is because in the IR things like `plet`
+     * are skipping some DeBruijin levels that are instead present
+     * in the final UPLC
+    **/
+    get dbn(): number;
+    set dbn(newDbn: number);
+    static get kind(): IRNodeKind.SelfCall;
+    get kind(): IRNodeKind.SelfCall;
+    static get tag(): Uint8Array;
+    readonly meta: IRSelfCallMetadata;
+    private _definition;
+    get definition(): IRRecursive;
+    set definition(newDefinition: IRRecursive | undefined);
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRParentTerm | undefined);
+    private _findDefinition;
+    constructor(DeBruijn: number | bigint);
+    clone(): IRSelfCall;
+    toJSON(): any;
+    toJson(): any;
+}

package/dist/IR/IRNodes/IRSelfCall.js

@@ -0,0 +1,127 @@
+import { BasePlutsError } from "../../utils/BasePlutsError.js";
+import { concatUint8Arr } from "../utils/concatUint8Arr.js";
+import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
+import { isIRParentTerm } from "../utils/isIRParentTerm.js";
+import { hashIrData, isIRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+import { IRRecursive } from "./IRRecursive.js";
+import { IRFunc } from "./IRFunc.js";
+export class IRSelfCall {
+    _hash;
+    get hash() {
+        if (!isIRHash(this._hash)) {
+            this._hash = getSelfCallHashAtDbn(this.dbn);
+        }
+        return this._hash;
+    }
+    /**
+     * called inside the dbn setter
+     */
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    isHashPresent() { return true; }
+    _dbn;
+    /**
+     * the IR DeBruijn index is not necessarly the same of the UPLC
+     * ( more ofthen than not it won't be the same )
+     *
+     * this is because in the IR things like `plet`
+     * are skipping some DeBruijin levels that are instead present
+     * in the final UPLC
+    **/
+    get dbn() { return this._dbn; }
+    set dbn(newDbn) {
+        if (!(Number.isSafeInteger(newDbn) && newDbn >= 0)) {
+            throw new BasePlutsError("invalid index for an `IRSelfCall` instance; new DeBruijn was: " + newDbn);
+        }
+        if (newDbn === this._dbn)
+            return; // everything ok
+        this.markHashAsInvalid();
+        this._dbn = newDbn;
+    }
+    static get kind() { return IRNodeKind.SelfCall; }
+    get kind() { return IRSelfCall.kind; }
+    static get tag() { return new Uint8Array([IRSelfCall.kind]); }
+    meta;
+    _definition;
+    get definition() {
+        if (!(this._definition instanceof IRRecursive)) {
+            this._definition = this._findDefinition();
+        }
+        return this._definition;
+    }
+    set definition(newDefinition) {
+        if (newDefinition === undefined) {
+            this._definition = undefined;
+            return;
+        }
+        else
+            throw new Error("IRSelfCall definition (IRRecursive parent) can't be changed unless set to undefined");
+    }
+    _parent;
+    get parent() { return this._parent; }
+    set parent(newParent) {
+        if (!( // assert
+        // new parent value is different than current
+        this._parent !== newParent && (
+        // and the new parent value is valid
+        newParent === undefined ||
+            isIRParentTerm(newParent))))
+            return;
+        // change parent
+        this._parent = newParent;
+        // if we change parent, _definition should be recalculated
+        this._definition = undefined;
+    }
+    _findDefinition() {
+        let node = this;
+        let dbn = this.dbn;
+        while (node.parent !== undefined) {
+            node = node.parent;
+            if (node instanceof IRRecursive ||
+                node instanceof IRFunc) {
+                if (dbn === 0) {
+                    if (node.parent instanceof IRRecursive)
+                        return node.parent;
+                    else
+                        throw new Error("IRSelfCall was pointing to a IRFunc node");
+                }
+                dbn -= node.arity;
+            }
+        }
+        throw new Error("IRSelfCall instance was not inside a IRRecursive instance");
+    }
+    constructor(DeBruijn) {
+        Object.defineProperty(this, "meta", {
+            value: {},
+            writable: false,
+            enumerable: true,
+            configurable: false
+        });
+        this._hash = undefined;
+        DeBruijn = typeof DeBruijn === "number" ? DeBruijn : Number(DeBruijn);
+        this._dbn = DeBruijn;
+        // call setter to check for validity
+        this.dbn = DeBruijn;
+        this._parent = undefined;
+    }
+    clone() {
+        return new IRSelfCall(this.dbn);
+    }
+    toJSON() { return this.toJson(); }
+    toJson() {
+        return {
+            type: "IRSelfCall",
+            dbn: this.dbn
+        };
+    }
+}
+const dbnSelfCallCache = {};
+function getSelfCallHashAtDbn(dbn) {
+    if (!isIRHash(dbnSelfCallCache[dbn])) {
+        dbnSelfCallCache[dbn] = (hashIrData(concatUint8Arr(IRSelfCall.tag, positiveIntAsBytes(dbn))));
+    }
+    return dbnSelfCallCache[dbn];
+}

package/dist/IR/IRNodes/IRVar.d.ts

@@ -0,0 +1,41 @@
+import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
+import { ToJson } from "../../utils/ToJson.js";
+import { IHash } from "../interfaces/IHash.js";
+import { IIRParent } from "../interfaces/IIRParent.js";
+import { IRParentTerm } from "../utils/isIRParentTerm.js";
+import { BaseIRMetadata } from "./BaseIRMetadata.js";
+import { IRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+export interface IRVarMetadata extends BaseIRMetadata {
+}
+export declare class IRVar implements Cloneable<IRVar>, IHash, IIRParent, ToJson {
+    private _hash;
+    get hash(): IRHash;
+    /**
+     * called inside the dbn setter
+     */
+    markHashAsInvalid(): void;
+    isHashPresent(): true;
+    private _dbn;
+    /**
+     * the IR DeBruijn index is not necessarly the same of the UPLC
+     * ( more ofthen than not it won't be the same )
+     *
+     * this is because in the IR things like `IRLetted` and `IRHoisted`
+     * are skipping some DeBruijin levels that are instead present
+     * in the final UPLC
+    **/
+    get dbn(): number;
+    set dbn(newDbn: number);
+    static get kind(): IRNodeKind.Var;
+    get kind(): IRNodeKind.Var;
+    static get tag(): Uint8Array;
+    readonly meta: IRVarMetadata;
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRParentTerm | undefined);
+    constructor(DeBruijn: number | bigint);
+    clone(): IRVar;
+    toJSON(): any;
+    toJson(): any;
+}

package/dist/IR/IRNodes/IRVar.js

@@ -0,0 +1,93 @@
+import { BasePlutsError } from "../../utils/BasePlutsError.js";
+import { concatUint8Arr } from "../utils/concatUint8Arr.js";
+import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
+import { isIRParentTerm } from "../utils/isIRParentTerm.js";
+import { hashIrData, isIRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+export class IRVar {
+    _hash;
+    get hash() {
+        if (!isIRHash(this._hash)) {
+            this._hash = getVarHashAtDbn(this.dbn);
+        }
+        return this._hash;
+    }
+    /**
+     * called inside the dbn setter
+     */
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    isHashPresent() { return true; }
+    _dbn;
+    /**
+     * the IR DeBruijn index is not necessarly the same of the UPLC
+     * ( more ofthen than not it won't be the same )
+     *
+     * this is because in the IR things like `IRLetted` and `IRHoisted`
+     * are skipping some DeBruijin levels that are instead present
+     * in the final UPLC
+    **/
+    get dbn() { return this._dbn; }
+    set dbn(newDbn) {
+        if (!(Number.isSafeInteger(newDbn) && newDbn >= 0)) {
+            // console.log( e.stack );
+            throw new BasePlutsError("invalid index for an `IRVar` instance; new DeBruijn was: " + newDbn);
+        }
+        if (newDbn === this._dbn)
+            return; // everything ok
+        this.markHashAsInvalid();
+        this._dbn = newDbn;
+    }
+    static get kind() { return IRNodeKind.Var; }
+    get kind() { return IRVar.kind; }
+    static get tag() { return new Uint8Array([IRVar.kind]); }
+    meta;
+    _parent;
+    get parent() { return this._parent; }
+    set parent(newParent) {
+        if (!( // assert
+        // new parent value is different than current
+        this._parent !== newParent && (
+        // and the new parent value is valid
+        newParent === undefined ||
+            isIRParentTerm(newParent))))
+            return;
+        // change parent
+        this._parent = newParent;
+    }
+    constructor(DeBruijn) {
+        Object.defineProperty(this, "meta", {
+            value: {},
+            writable: false,
+            enumerable: true,
+            configurable: false
+        });
+        this._hash = undefined;
+        DeBruijn = typeof DeBruijn === "number" ? DeBruijn : Number(DeBruijn);
+        this._dbn = DeBruijn;
+        // call setter to check for validity
+        this.dbn = DeBruijn;
+        this._parent = undefined;
+    }
+    clone() {
+        return new IRVar(this.dbn);
+    }
+    toJSON() { return this.toJson(); }
+    toJson() {
+        return {
+            type: "IRVar",
+            dbn: this.dbn
+        };
+    }
+}
+const _bdnVarHashCache = new Map();
+function getVarHashAtDbn(dbn) {
+    const cached = _bdnVarHashCache.get(dbn)?.deref();
+    if (isIRHash(cached))
+        return cached;
+    const hash = hashIrData(concatUint8Arr(IRVar.tag, positiveIntAsBytes(dbn)));
+    _bdnVarHashCache.set(dbn, new WeakRef(hash));
+    return hash;
+}

package/dist/IR/IRNodes/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./IRApp.js";
+export * from "./IRConst.js";
+export * from "./IRDelayed.js";
+export * from "./IRError.js";
+export * from "./IRForced.js";
+export * from "./IRFunc.js";
+export * from "./IRHoisted.js";
+export * from "./IRLetted.js";
+export * from "./IRNative/index.js";
+export * from "./IRVar.js";
+export * from "./IRConstr.js";
+export * from "./IRCase.js";

package/dist/IR/IRNodes/index.js

@@ -0,0 +1,12 @@
+export * from "./IRApp.js";
+export * from "./IRConst.js";
+export * from "./IRDelayed.js";
+export * from "./IRError.js";
+export * from "./IRForced.js";
+export * from "./IRFunc.js";
+export * from "./IRHoisted.js";
+export * from "./IRLetted.js";
+export * from "./IRNative/index.js";
+export * from "./IRVar.js";
+export * from "./IRConstr.js";
+export * from "./IRCase.js";

package/dist/IR/IRNodes/utils/dependsByDbns.d.ts

@@ -0,0 +1,5 @@
+import { IRTerm } from "../../IRTerm.js";
+/**
+ * returns true if the term depends on *ANY* of the deBrujin indices specified
+ */
+export declare function dependsByDbns(term: IRTerm, depsDbns: readonly number[]): boolean;

package/dist/IR/IRNodes/utils/dependsByDbns.js

@@ -0,0 +1,29 @@
+import { iterTree } from "../../toUPLC/_internal/iterTree.js";
+import { IRSelfCall } from "../IRSelfCall.js";
+import { IRVar } from "../IRVar.js";
+/**
+ * returns true if the term depends on *ANY* of the deBrujin indices specified
+ */
+export function dependsByDbns(term, depsDbns) {
+    if (depsDbns.length === 0)
+        return false;
+    let doesDepend = false;
+    iterTree(term, (node, diff) => {
+        if (node instanceof IRVar ||
+            node instanceof IRSelfCall) {
+            doesDepend = doesDepend || depsDbns.some(dbn => {
+                const realDbn = dbn + diff;
+                // realDbn === 0 implies no variables are in scope
+                // so if node.dbn === 0 and realDbn === 1 then the 
+                // variable is pointing to that definition
+                return node.dbn === realDbn;
+            });
+        }
+    }, 
+    // shouldSkipNode
+    undefined, 
+    // shouldStop
+    () => doesDepend // exit early
+    );
+    return doesDepend;
+}

package/dist/IR/IRNodes/utils/isClosedAtDbn.d.ts

@@ -0,0 +1,2 @@
+import { IRTerm } from "../../IRTerm.js";
+export declare function isClosedAtDbn(term: IRTerm, dbn?: number): boolean;

package/dist/IR/IRNodes/utils/isClosedAtDbn.js

@@ -0,0 +1,22 @@
+import { iterTree } from "../../toUPLC/_internal/iterTree.js";
+import { IRSelfCall } from "../IRSelfCall.js";
+import { IRVar } from "../IRVar.js";
+export function isClosedAtDbn(term, dbn = 0) {
+    let isClosed = true;
+    iterTree(term, (node, diff) => {
+        const realDbn = dbn + diff;
+        if (node instanceof IRVar ||
+            node instanceof IRSelfCall) {
+            // realDbn === 0 implies no variables are in scope
+            // so if node.dbn === 0 and realDbn === 0 then the variable is open
+            // and is pointing outside of the scope
+            isClosed = isClosed || node.dbn < realDbn;
+        }
+    }, 
+    // shouldSkipNode
+    undefined, 
+    // shouldStop
+    () => !isClosed // exit early
+    );
+    return isClosed;
+}

package/dist/IR/IRNodes/utils/makeArrayLikeProxy.d.ts

@@ -0,0 +1 @@
+export declare function makeArrayLikeProxy<T>(arr: ArrayLike<T>, isValidElem: (elem: T) => boolean, initModifyElem: (elem: T) => T, modifyElem: (elem: T, oldElem: T) => T): ArrayLike<T>;

package/dist/IR/IRNodes/utils/makeArrayLikeProxy.js

@@ -0,0 +1,34 @@
+export function makeArrayLikeProxy(arr, isValidElem, initModifyElem, modifyElem) {
+    const like = {};
+    Object.defineProperty(like, "length", {
+        value: arr.length,
+        writable: false,
+        enumerable: false,
+        configurable: false
+    });
+    const clonedArr = Array.from(arr);
+    for (let i = 0; i < arr.length; i++) {
+        clonedArr[i] = initModifyElem(arr[i]);
+        Object.defineProperty(like, i, {
+            get: () => clonedArr[i],
+            set: (newElem) => {
+                if (isValidElem(newElem))
+                    clonedArr[i] = modifyElem(newElem, clonedArr[i]);
+                return newElem;
+            },
+            enumerable: true,
+            configurable: false
+        });
+    }
+    Object.defineProperty(like, Symbol.iterator, {
+        value: iterArrayLikeProxy.bind(like),
+        writable: false,
+        enumerable: false,
+        configurable: false
+    });
+    return like;
+}
+function* iterArrayLikeProxy() {
+    for (let i = 0; i < this.length; i++)
+        yield this[i];
+}

package/dist/IR/IRNodes/utils/mapArrayLike.d.ts

@@ -0,0 +1 @@
+export declare function mapArrayLike<T, Out>(arr: ArrayLike<T>, fn: (elem: T, idx: number, thisArr: ArrayLike<T>) => Out): Out[];

package/dist/IR/IRNodes/utils/mapArrayLike.js

@@ -0,0 +1,8 @@
+export function mapArrayLike(arr, fn) {
+    const len = arr.length;
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = fn(arr[i], i, arr);
+    }
+    return result;
+}

package/dist/IR/IRTerm.d.ts

@@ -0,0 +1,15 @@
+import { IRApp } from "./IRNodes/IRApp.js";
+import { IRConst } from "./IRNodes/IRConst.js";
+import { IRFunc } from "./IRNodes/IRFunc.js";
+import { IRHoisted } from "./IRNodes/IRHoisted.js";
+import { IRLetted } from "./IRNodes/IRLetted.js";
+import { IRNative } from "./IRNodes/IRNative/index.js";
+import { IRError } from "./IRNodes/IRError.js";
+import { IRDelayed } from "./IRNodes/IRDelayed.js";
+import { IRForced } from "./IRNodes/IRForced.js";
+import { IRVar } from "./IRNodes/IRVar.js";
+import { IRConstr } from "./IRNodes/IRConstr.js";
+import { IRCase } from "./IRNodes/IRCase.js";
+import { IRRecursive } from "./IRNodes/IRRecursive.js";
+import { IRSelfCall } from "./IRNodes/IRSelfCall.js";
+export type IRTerm = IRVar | IRFunc | IRApp | IRConst | IRNative | IRLetted | IRHoisted | IRError | IRForced | IRDelayed | IRConstr | IRCase | IRRecursive | IRSelfCall;

package/dist/IR/IRTerm.js

@@ -0,0 +1 @@
+export {};

package/dist/IR/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./IRTerm.js";
+export * from "./IRNodes/index.js";
+export * from "./interfaces/index.js";
+export * from "./toUPLC/index.js";
+export * from "./utils/index.js";

package/dist/IR/index.js

@@ -0,0 +1,5 @@
+export * from "./IRTerm.js";
+export * from "./IRNodes/index.js";
+export * from "./interfaces/index.js";
+export * from "./toUPLC/index.js";
+export * from "./utils/index.js";

package/dist/IR/interfaces/IHash.d.ts

@@ -0,0 +1,6 @@
+import { IRHash } from "../IRHash.js";
+export interface IHash {
+    readonly hash: IRHash;
+    markHashAsInvalid: () => void;
+    isHashPresent: () => boolean;
+}

package/dist/IR/interfaces/IHash.js

@@ -0,0 +1 @@
+export {};

package/dist/IR/interfaces/IIRParent.d.ts

@@ -0,0 +1,4 @@
+import { IRTerm } from "../IRTerm.js";
+export interface IIRParent {
+    parent: IRTerm | undefined;
+}

package/dist/IR/interfaces/IIRParent.js

@@ -0,0 +1 @@
+export {};

package/dist/IR/interfaces/IRMetadata.d.ts

@@ -0,0 +1,3 @@
+export interface IRMetadata {
+    meta: object;
+}

package/dist/IR/interfaces/IRMetadata.js

@@ -0,0 +1,2 @@
+;
+export {};

package/dist/IR/interfaces/ToIR.d.ts

@@ -0,0 +1,5 @@
+import { IRTerm } from "../IRTerm.js";
+import { CompilerOptions } from "../toUPLC/CompilerOptions.js";
+export interface ToIR {
+    toIR: (config: CompilerOptions, dbn?: number | bigint) => IRTerm;
+}

package/dist/IR/interfaces/ToIR.js

@@ -0,0 +1 @@
+export {};

package/dist/IR/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./IHash.js";
+export * from "./IIRParent.js";
+export * from "./IRMetadata.js";
+export * from "./ToIR.js";

package/dist/IR/interfaces/index.js

@@ -0,0 +1,4 @@
+export * from "./IHash.js";
+export * from "./IIRParent.js";
+export * from "./IRMetadata.js";
+export * from "./ToIR.js";