@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

package/dist/IR/toUPLC/_internal/findAll.js

@@ -1,99 +0,0 @@
-import { IRCase, IRConstr } from "../../IRNodes/index.js";
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-export function findAll(term, predicate) {
-    const stack = [term];
-    const result = [];
-    while (stack.length > 0) {
-        const t = stack.pop();
-        if (predicate(t))
-            result.push(t);
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            stack.push(t.hoisted);
-            continue;
-        }
-        if (t instanceof IRLetted) {
-            // same stuff as the hoisted terms
-            // the only difference is that depth is then incremented
-            // once the letted term reaches its final position
-            stack.push(t.value);
-            continue;
-        }
-    }
-    return result;
-}
-export function findAllNoHoisted(term, predicate) {
-    const stack = [term];
-    const result = [];
-    while (stack.length > 0) {
-        const t = stack.pop();
-        if (predicate(t))
-            result.push(t);
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push(t.constrTerm, ...t.continuations);
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...t.fields);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            // this is `findAllNoHoisted` remember?
-            // stack.push( t.hoisted );
-            continue;
-        }
-        if (t instanceof IRLetted) {
-            // same stuff as the hoisted terms
-            // the only difference is that depth is then incremented
-            // once the letted term reaches its final position
-            stack.push(t.value);
-            continue;
-        }
-    }
-    return result;
-}

package/dist/IR/toUPLC/_internal/getDebruijnInTerm.d.ts

@@ -1,2 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export declare function getDebruijnInTerm(root: IRTerm, termToFind: IRTerm): number;

package/dist/IR/toUPLC/_internal/getDebruijnInTerm.js

@@ -1,51 +0,0 @@
-import { equalIrHash } from "../../IRHash.js";
-import { IRCase, IRConstr } from "../../IRNodes/index.js";
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-import { mapArrayLike } from "../../IRNodes/utils/mapArrayLike.js";
-export function getDebruijnInTerm(root, termToFind) {
-    const termTofindHash = termToFind.hash;
-    const stack = [{ term: root, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term, dbn } = stack.pop();
-        if (term === termToFind || equalIrHash(term.hash, termTofindHash))
-            return dbn;
-        if (term instanceof IRApp) {
-            stack.push({ term: term.fn, dbn }, { term: term.arg, dbn });
-            continue;
-        }
-        if (term instanceof IRCase) {
-            stack.push({ term: term.constrTerm, dbn }, ...mapArrayLike(term.continuations, (continuation) => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (term instanceof IRConstr) {
-            stack.push(...mapArrayLike(term.fields, (field) => ({ term: field, dbn })));
-            continue;
-        }
-        if (term instanceof IRDelayed) {
-            stack.push({ term: term.delayed, dbn });
-            continue;
-        }
-        if (term instanceof IRForced) {
-            stack.push({ term: term.forced, dbn });
-            continue;
-        }
-        if (term instanceof IRFunc) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
-            continue;
-        }
-        if (term instanceof IRRecursive) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
-            continue;
-        }
-        if (term instanceof IRLetted) {
-            stack.push({ term: term.value, dbn });
-            continue;
-        }
-    }
-    return -1;
-}

package/dist/IR/toUPLC/_internal/getDiffDbn.d.ts

@@ -1,2 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export declare function getDiffDbn(parentNode: IRTerm, childNode: IRTerm): number | undefined;

package/dist/IR/toUPLC/_internal/getDiffDbn.js

@@ -1,55 +0,0 @@
-import { IRCase } from "../../IRNodes/IRCase.js";
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { mapArrayLike } from "../../IRNodes/utils/mapArrayLike.js";
-import { IRConstr } from "../../IRNodes/index.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-export function getDiffDbn(parentNode, childNode) {
-    const stack = [{ term: parentNode, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term: t, dbn } = stack.pop();
-        if (t === childNode)
-            return dbn;
-        if (t instanceof IRLetted) {
-            stack.push({ term: t.value, dbn });
-            continue;
-        }
-        if (t instanceof IRApp) {
-            stack.push({ term: t.fn, dbn }, { term: t.arg, dbn });
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push({ term: t.constrTerm, dbn }, ...mapArrayLike(t.continuations, continuation => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...mapArrayLike(t.fields, field => ({ term: field, dbn })));
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, dbn });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, dbn });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            stack.push({ term: t.hoisted, dbn });
-            continue;
-        }
-    }
-    return undefined;
-}

package/dist/IR/toUPLC/_internal/includesLettedTerms.d.ts

@@ -1,2 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export declare function includesLettedTerms(_term: IRTerm): boolean;

package/dist/IR/toUPLC/_internal/includesLettedTerms.js

@@ -1,50 +0,0 @@
-import { IRCase, IRConstr } from "../../IRNodes/index.js";
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-export function includesLettedTerms(_term) {
-    const stack = [_term];
-    while (stack.length > 0) {
-        const t = stack.pop();
-        if (t instanceof IRLetted) {
-            return true;
-        }
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push(t.constrTerm, ...t.continuations);
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...t.fields);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            stack.push(t.hoisted);
-            continue;
-        }
-    }
-    return false;
-}

package/dist/IR/toUPLC/_internal/includesNode.d.ts

@@ -1,2 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export declare function includesNode(parent: IRTerm, predicate: (node: IRTerm) => boolean): boolean;

package/dist/IR/toUPLC/_internal/includesNode.js

@@ -1,54 +0,0 @@
-import { IRCase } from "../../IRNodes/IRCase.js";
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRConstr } from "../../IRNodes/IRConstr.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-export function includesNode(parent, predicate) {
-    const stack = [parent];
-    while (stack.length > 0) {
-        const t = stack.pop();
-        if (predicate(t))
-            return true;
-        if (t instanceof IRLetted) {
-            stack.push(t.value);
-            continue;
-        }
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push(t.constrTerm, ...t.continuations);
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...t.fields);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            stack.push(t.hoisted);
-            continue;
-        }
-    }
-    return false;
-}

package/dist/IR/toUPLC/_internal/iterTree.d.ts

@@ -1,2 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export declare function iterTree(_term: IRTerm, fn: (elem: IRTerm, dbn: number) => (boolean | undefined | void), shouldSkipNode?: (elem: IRTerm, dbn: number) => boolean, shouldExit?: (elem: IRTerm, dbn: number) => boolean): void;

package/dist/IR/toUPLC/_internal/iterTree.js

@@ -1,93 +0,0 @@
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRCase } from "../../IRNodes/IRCase.js";
-import { IRConstr } from "../../IRNodes/IRConstr.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-export function iterTree(_term, fn, 
-// necessary for letted hash calculation (exclude hoisted)
-shouldSkipNode, shouldExit) {
-    const has_shouldSkipNode = typeof shouldSkipNode === "function";
-    const has_shouldExit = typeof shouldExit === "function";
-    const stack = [{ term: _term, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term: t, dbn } = stack.pop();
-        if (has_shouldSkipNode && shouldSkipNode(t, dbn))
-            continue;
-        const termParent = t.parent;
-        const negDbn = t instanceof IRFunc || t instanceof IRRecursive ? t.arity : 0;
-        const modifiedParent = fn(t, dbn) === true;
-        if (has_shouldExit && shouldExit(t, dbn))
-            return;
-        if (modifiedParent && termParent !== undefined) {
-            while (stack.length > 0 && stack[stack.length - 1].shouldPopIfParentIsModified) {
-                // there is an extra node 
-                stack.pop();
-            }
-            // restart from the parent
-            stack.push({ term: termParent, dbn: dbn - negDbn });
-            continue;
-        }
-        if (t instanceof IRApp) {
-            // sanifyTree as we go
-            if (t.fn.parent !== t)
-                t.fn = t.fn.clone();
-            if (t.arg.parent !== t)
-                t.arg = t.arg.clone();
-            stack.push({ term: t.fn, dbn }, { term: t.arg, dbn, shouldPopIfParentIsModified: true });
-            continue;
-        }
-        if (t instanceof IRCase) {
-            // sanifyTree as we go
-            if (t.constrTerm.parent !== t)
-                t.constrTerm = t.constrTerm.clone();
-            for (let i = 0; i < t.continuations.length; i++) {
-                if (t.continuations[i].parent !== t)
-                    t.continuations[i] = t.continuations[i].clone();
-            }
-            stack.push({ term: t.constrTerm, dbn }, ...Array.from(t.continuations).map(cont => ({ term: cont, dbn, shouldPopIfParentIsModified: true })));
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            // sanifyTree as we go
-            for (let i = 0; i < t.fields.length; i++) {
-                if (t.fields[i].parent !== t)
-                    t.fields[i] = t.fields[i].clone();
-            }
-            stack.push(...Array.from(t.fields).map((f, i) => ({ term: f, dbn, shouldPopIfParentIsModified: i !== 0 })));
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, dbn });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, dbn });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            // 0 because hoisted are closed
-            // for hoisted we keep track of the depth inside the term
-            stack.push({ term: t.hoisted, dbn: 0 });
-            continue;
-        }
-        if (t instanceof IRLetted) {
-            // same stuff as the hoisted terms
-            // the only difference is that depth is then incremented
-            // once the letted term reaches its final position
-            stack.push({ term: t.value, dbn });
-            continue;
-        }
-    }
-}

package/dist/IR/toUPLC/_internal/lowestCommonAncestor.d.ts

@@ -1,3 +0,0 @@
-import type { IRTerm } from "../../IRTerm.js";
-export declare function getDepthInMaxScope(term: IRTerm, maxScope: IRTerm): number | undefined;
-export declare function lowestCommonAncestor(n1: IRTerm | undefined, n2: IRTerm | undefined, maxScope: IRTerm): IRTerm | undefined;

package/dist/IR/toUPLC/_internal/lowestCommonAncestor.js

@@ -1,41 +0,0 @@
-import { isIRTerm } from "../../utils/isIRTerm.js";
-// type IRWithDepth = IRTerm & { depth: number }
-export function getDepthInMaxScope(term, maxScope) {
-    let depth = 0;
-    while (term.parent !== maxScope) {
-        depth++;
-        if (term.parent === undefined)
-            return undefined;
-        term = term.parent;
-    }
-    return depth;
-}
-export function lowestCommonAncestor(n1, n2, maxScope) {
-    if (!isIRTerm(n1) || !isIRTerm(n2))
-        return undefined;
-    let d1 = getDepthInMaxScope(n1, maxScope);
-    let d2 = getDepthInMaxScope(n2, maxScope);
-    if (d1 === undefined || d2 === undefined) {
-        return undefined;
-    }
-    let diff = d1 - d2;
-    // If node b is deeper, swap node a and node b
-    if (diff < 0) {
-        let temp = n1;
-        n1 = n2;
-        n2 = temp;
-        diff = -diff;
-    }
-    // Move n1 up until it reaches the same level as n2
-    while (diff-- > 0 && n1.parent)
-        n1 = n1.parent;
-    // Now n1 and n2 are at same levels
-    while (n1 && n2) {
-        if (n1 === n2)
-            return n1;
-        // undefined will exit the loop 
-        n1 = n1.parent;
-        n2 = n2.parent;
-    }
-    return undefined;
-}

package/dist/IR/toUPLC/compileIRToUPLC.d.ts

@@ -1,4 +0,0 @@
-import type { UPLCTerm } from "@harmoniclabs/uplc";
-import type { IRTerm } from "../IRTerm.js";
-import { CompilerOptions } from "./CompilerOptions.js";
-export declare function compileIRToUPLC(term: IRTerm, paritalOptions?: Partial<CompilerOptions>): UPLCTerm;

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -1,118 +0,0 @@
-import { IRLetted } from "../IRNodes/IRLetted.js";
-import { IRHoisted } from "../IRNodes/IRHoisted.js";
-import { IRConst } from "../IRNodes/IRConst.js";
-import { _irToUplc } from "./_internal/_irToUplc.js";
-import { includesNode } from "./_internal/includesNode.js";
-import { handleLettedAndReturnRoot } from "./subRoutines/handleLetted/index.js";
-import { handleHoistedAndReturnRoot } from "./subRoutines/handleHoistedAndReturnRoot/index.js";
-import { replaceNativesAndReturnRoot } from "./subRoutines/replaceNatives/index.js";
-import { replaceClosedLettedWithHoisted } from "./subRoutines/replaceClosedLettedWithHoisted.js";
-import { hoistForcedNatives } from "./subRoutines/hoistForcedNatives.js";
-import { handleRootRecursiveTerm } from "./subRoutines/handleRecursiveTerms.js";
-import { completeCompilerOptions, defaultOptions } from "./CompilerOptions.js";
-import { replaceHoistedWithLetted } from "./subRoutines/replaceHoistedWithLetted.js";
-import { IRCase, IRConstr, IRNative } from "../IRNodes/index.js";
-import { replaceForcedNativesWithHoisted } from "./subRoutines/replaceForcedNativesWithHoisted.js";
-import { performUplcOptimizationsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/index.js";
-export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
-    // most of the time we are just compiling small
-    // pre-execuded terms (hence constants)
-    if (term instanceof IRConst)
-        return _irToUplc(term).term;
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // --------------------------------- init  --------------------------------- //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
-    const options = completeCompilerOptions(paritalOptions);
-    // unwrap top level letted and hoisted;
-    while (term instanceof IRLetted || term instanceof IRHoisted) {
-        // replace with value
-        term = term instanceof IRLetted ? term.value : term.hoisted;
-        // forget the parent; this is the new root
-        term.parent = undefined;
-    }
-    // _makeAllNegativeNativesHoisted( term );
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // ----------------------------- optimizations ----------------------------- //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
-    // --------------------------- optimize natives  --------------------------- //
-    // at constant -> head and tails
-    // --------------------- optimize recursive functions  --------------------- //
-    // avoid passing whole structs
-    // take letted terms outside
-    // ----------------------- optimize normal functions ----------------------- //
-    // avoid passing whole structs
-    // reorganize function arguments to take advantage of partial applicaiton
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // ------------------------------ final steps ------------------------------ //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
-    term = replaceNativesAndReturnRoot(term);
-    // unwrap top level letted and hoisted;
-    // some natives may be converted to hoisted;
-    // this is really just an edge case
-    while (term instanceof IRLetted || term instanceof IRHoisted) {
-        // replace with value
-        term = term instanceof IRLetted ? term.value : term.hoisted;
-        // forget the parent; this is the new root
-        term.parent = undefined;
-    }
-    if (term instanceof IRNative ||
-        term instanceof IRConst // while we are at it
-    )
-        return _irToUplc(term).term;
-    if (options.delayHoists)
-        replaceForcedNativesWithHoisted(term);
-    if (options.delayHoists)
-        replaceHoistedWithLetted(term);
-    else
-        replaceClosedLettedWithHoisted(term);
-    // handle letted before hoisted because the tree is smaller
-    // and we also have less letted dependecies to handle
-    term = handleLettedAndReturnRoot(term);
-    term = handleHoistedAndReturnRoot(term);
-    // replaced hoisted terms might include new letted terms
-    while (includesNode(term, node => node instanceof IRLetted ||
-        node instanceof IRHoisted)) {
-        term = handleLettedAndReturnRoot(term);
-        term = handleHoistedAndReturnRoot(term);
-    }
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // --------------------------- translate to UPLC --------------------------- //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
-    // introduces new hoisted terms
-    // however we cannot do this before
-    // because in order to hanlde letted at the best
-    // we need to know where the `IRRecursive` nodes are
-    term = handleRootRecursiveTerm(term);
-    // if( options.delayHoists ) replaceHoistedWithLetted( term );
-    // handle new hoisted terms
-    term = handleHoistedAndReturnRoot(term);
-    // strictly necessary to check the options
-    // otherwise forced natives where already hoisted
-    // will be re-hosited; causeing uselsess evaluations
-    if (!options.delayHoists)
-        term = hoistForcedNatives(term);
-    // at this point we expect the IR to be translable 1:1 to UPLC
-    term = performUplcOptimizationsAndReturnRoot(term, options);
-    if (options.addMarker &&
-        options.targetUplcVersion.major >= 1 &&
-        options.targetUplcVersion.minor >= 1 &&
-        options.targetUplcVersion.patch >= 0) {
-        term = new IRCase(new IRConstr(0, []), [
-            term,
-            // never evaluated
-            IRConst.int(42)
-        ]);
-    }
-    const srcmap = {};
-    const uplc = _irToUplc(term, srcmap).term;
-    // console.log( "srcmap", srcmap );
-    return uplc;
-}

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

@@ -1 +0,0 @@
-export * from "./compileIRToUPLC.js";

package/dist/IR/toUPLC/index.js

@@ -1 +0,0 @@
-export * from "./compileIRToUPLC.js";

package/dist/IR/toUPLC/subRoutines/handleHoistedAndReturnRoot/index.d.ts

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