@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

package/dist/IR/toUPLC/subRoutines/handleLetted/index.js

@@ -1,304 +0,0 @@
-import { IRApp } from "../../../IRNodes/IRApp.js";
-import { IRFunc } from "../../../IRNodes/IRFunc.js";
-import { getSortedLettedSet, getLettedTerms, IRLetted } from "../../../IRNodes/IRLetted.js";
-import { IRVar } from "../../../IRNodes/IRVar.js";
-import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
-import { findAllNoHoisted } from "../../_internal/findAll.js";
-import { getDebruijnInTerm } from "../../_internal/getDebruijnInTerm.js";
-import { _getMinUnboundDbn } from "./groupByScope.js";
-import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IRNodes/IRForced.js";
-import { lowestCommonAncestor } from "../../_internal/lowestCommonAncestor.js";
-import { isIRTerm } from "../../../utils/isIRTerm.js";
-import { markRecursiveHoistsAsForced } from "../markRecursiveHoistsAsForced.js";
-import { IRConst } from "../../../IRNodes/IRConst.js";
-import { incrementUnboundDbns } from "./incrementUnboundDbns.js";
-import { equalIrHash, irHashToHex } from "../../../IRHash.js";
-import { sanifyTree } from "../sanifyTree.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
-import { IRCase } from "../../../IRNodes/IRCase.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
-import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
-import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
-import { findHighestRecursiveParent } from "./findHighestRecursiveParent.js";
-export function handleLettedAndReturnRoot(term) {
-    // console.log(" ------------------------------------------- handleLetted ------------------------------------------- ");
-    // console.log( prettyIRText( term ))
-    // most of the time we are just compiling small
-    // pre-execuded terms (hence constants)
-    if (term instanceof IRConst)
-        return term;
-    // TODO: should probably merge `markRecursiveHoistsAsForced` inside `getLettedTerms` to iter once
-    markRecursiveHoistsAsForced(term);
-    // in case there are no letted terms there is no work to do
-    while (true) {
-        const allDirectLetted = getLettedTerms(term, { all: false, includeHoisted: false });
-        if (allDirectLetted.length === 0)
-            return term;
-        const sortedLettedSet = getSortedLettedSet(allDirectLetted);
-        const { letted, nReferences } = sortedLettedSet.pop();
-        /*
-        const _lettedValue_ = letted.value;
-        const shouldLog = (
-            _lettedValue_ instanceof IRApp &&
-            _lettedValue_.fn instanceof IRFunc &&
-            _lettedValue_.fn.arity === 1 &&
-            _lettedValue_.fn.body instanceof IRLetted &&
-            equalIrHash( _lettedValue_.fn.body.hash, new Uint32Array( fromHex("71030a2d7560e563fe25fd782edd847f").buffer ) as IRHash ) &&
-            _lettedValue_.arg instanceof IRLetted &&
-            equalIrHash( _lettedValue_.arg.hash, new Uint32Array( fromHex("82dfb8a2f2703fe59fb25f8372e5e958").buffer ) as IRHash )
-        );
-        //*/
-        // shouldLog && console.log("nReferences", nReferences);
-        // console.log(` ------------------ working with ${lettedToStr(letted)} ------------------ `);
-        if (nReferences === 1) {
-            // console.log("inlining letted (single reference) with value", prettyIRText( letted.value ) )
-            _modifyChildFromTo(letted.parent, letted, letted.value);
-            continue;
-        }
-        const maxScope = findLettedMaxScope(letted) ?? (() => {
-            if (letted.meta.isClosed || letted.isClosedAtDbn(0)) {
-                // value is closed (hoisted),
-                // so the max scope is the entire script
-                return term;
-            }
-            else
-                throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}`);
-        })();
-        const lettedTermCanBeHoisted = maxScope === term;
-        const minScope = findHighestRecursiveParent(letted, maxScope);
-        sanifyTree(maxScope);
-        const lettedHash = letted.hash;
-        const sameLettedRefs = findAllNoHoisted(maxScope, node => node instanceof IRLetted &&
-            equalIrHash(node.hash, lettedHash));
-        if (sameLettedRefs.length <= 0) {
-            console.warn("how did you get here? 0 references found for letted term;\n\n" +
-                "!!! PLEASE OPEN AN ISSUE ON GITHUB (https://github.com/HarmonicLabs/plu-ts/issues) !!!\n\n");
-            continue;
-        }
-        // just in case
-        if (sameLettedRefs.length === 1 && !minScope) {
-            // console.log("inlining letted (single reference pedantic) with value", prettyIRText( letted.value ) )
-            _modifyChildFromTo(letted.parent, letted, letted.value);
-            continue;
-        }
-        // always inline letted vars
-        if (letted.value instanceof IRVar ||
-            letted.value instanceof IRSelfCall) {
-            // console.log("inlining letted (value is var) with value", prettyIRText( letted.value ) )
-            for (const elem of sameLettedRefs) {
-                // inline
-                _modifyChildFromTo(elem.parent, elem, elem.value);
-            }
-            continue;
-        }
-        let lca = minScope ?? sameLettedRefs[0];
-        // const forceHoist = false && sameLettedRefs.some( letted => letted.meta.forceHoist === true );
-        for (let j = 1; j < sameLettedRefs.length; j++) {
-            const prevLca = lca;
-            lca = lowestCommonAncestor(lca, sameLettedRefs[j], maxScope);
-            if (!isIRTerm(lca)) {
-                lca = prevLca;
-            }
-            ;
-        }
-        if (!isIRTerm(lca)) {
-            throw new Error("letting nodes with hash " + irHashToHex(lettedHash) + " from different trees");
-        }
-        const realLca = lca;
-        // point to the first func or delay node above the lca
-        // (worst case scenario we hit the maxScope; which is an IRFunc)
-        // IRFuncs should always be under IRRecursives if any
-        while (!(lca instanceof IRFunc ||
-            lca instanceof IRDelayed) && lca) {
-            lca = lca?.parent ?? undefined;
-        }
-        if (!isIRTerm(lca)) {
-            if (!lettedTermCanBeHoisted)
-                throw new Error("lowest common ancestor outside the max scope");
-            lca = realLca;
-            const tmpRoot = handleLettedAsHoistedAndReturnRoot(letted, realLca, // lca
-            sameLettedRefs, term);
-            if (lca === maxScope || !lca.parent)
-                term = tmpRoot;
-            continue;
-        }
-        const parentNode = lca;
-        const parentNodeDirectChild = (parentNode instanceof IRFunc ||
-            parentNode instanceof IRRecursive) ? parentNode.body : parentNode.delayed;
-        // add 1 to every var's DeBruijn that accesses stuff outside the parent node
-        // not including the `parentNode` node
-        // since the new function introdcued substituting the letted term
-        // is added inside the `parentNode` node
-        incrementUnboundDbns(parentNodeDirectChild, 
-        // `shouldNotModifyLetted` arg (given the hash returns `true` if it should NOT modify the term)
-        // this callback is ONLY called on LETTED terms
-        ({ hash }) => equalIrHash(hash, lettedHash));
-        // now we replace
-        const lettedValue = letted.value.clone();
-        modifyValueToLetDbns(lettedValue, getDiffDbn(letted, parentNode));
-        const newNode = new IRApp(new IRFunc(1, parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
-        // replace child with new node
-        if (parentNode instanceof IRFunc || parentNode instanceof IRRecursive)
-            parentNode.body = newNode;
-        else
-            parentNode.delayed = newNode;
-        for (const ref of sameLettedRefs) {
-            _modifyChildFromTo(ref.parent, ref, new IRVar(getDebruijnInTerm(parentNodeDirectChild, ref)));
-        }
-        // const delayed = parentNode instanceof IRDelayed;
-        // let finalMaxScope: IRFunc | IRDelayed = parentNode;
-        // while(!(
-        //     finalMaxScope instanceof IRFunc ||
-        //     finalMaxScope instanceof IRDelayed
-        // ))
-        // {
-        //     finalMaxScope = (finalMaxScope as any).parent as any
-        // }
-        // console.log("final max scope (delayed: " + delayed + ")" , prettyIRText( finalMaxScope ) )
-    }
-}
-/**
- *
- * @param letted
- * @returns {IRFunc} the lowest `IRFunc` in the tree that defines all the variables needed for the
- */
-function findLettedMaxScope(letted) {
-    let minUnboundDbn = _getMinUnboundDbn(letted.value);
-    if (minUnboundDbn === undefined) {
-        let tmp = letted;
-        let maxScope = undefined;
-        while (tmp.parent) {
-            tmp = tmp.parent;
-            if (tmp instanceof IRFunc || tmp instanceof IRDelayed)
-                maxScope = tmp;
-        }
-        ;
-        return maxScope;
-    }
-    let tmp = letted;
-    let maxScope = undefined;
-    while (minUnboundDbn >= 0) {
-        if (!tmp.parent) {
-            throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}; ` +
-                `the max parent found leaves the term open (reached root)`);
-        }
-        tmp = tmp.parent;
-        if (tmp instanceof IRRecursive) {
-            minUnboundDbn -= tmp.arity;
-            // maxScope = tmp; // recursive cannot be a max scope
-        }
-        else if (tmp instanceof IRFunc) {
-            minUnboundDbn -= tmp.arity;
-            maxScope = tmp;
-        }
-    }
-    // just ts sillyness here
-    if (!maxScope) {
-        throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}; ` +
-            `no IRFunc found`);
-    }
-    return maxScope;
-}
-function modifyValueToLetDbns(lettedValue, diffDbn) {
-    if (diffDbn <= 0)
-        return;
-    // if there is any actual difference between the letted term
-    // and the position where it will be finally placed
-    // the value needs to be modified accoridingly
-    const stack = [{ term: lettedValue, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term: t, dbn } = stack.pop();
-        if ((t instanceof IRVar ||
-            t instanceof IRSelfCall) &&
-            t.dbn > dbn) {
-            t.dbn -= diffDbn;
-        }
-        if (t instanceof IRLetted) {
-            t.dbn -= diffDbn;
-            // reduce dbn in letted value too
-            stack.push({ term: t.value, dbn });
-            continue;
-        }
-        if (t instanceof IRApp) {
-            stack.push({ term: t.arg, dbn }, { term: t.fn, 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;
-        }
-        // no hoisted
-    }
-}
-/**
- * @returns the difference in DeBruijn
- * between the maxScope and the letted term
- */
-function getDiffDbn(letted, parentNode) {
-    // get the difference in DeBruijn
-    // between the maxScope and the letted term
-    let diffDbn = 0;
-    //*
-    let tmpNode = letted;
-    while (tmpNode !== parentNode) {
-        tmpNode = tmpNode.parent;
-        if ( // is an intermediate `IRFunc`
-        (tmpNode instanceof IRFunc ||
-            tmpNode instanceof IRRecursive) &&
-            tmpNode !== parentNode // avoid counting parent node arity if IRFunc 
-        ) {
-            // increment differential in DeBruijn by n vars indroduced here
-            diffDbn += tmpNode.arity;
-        }
-    }
-    return diffDbn;
-}
-function handleLettedAsHoistedAndReturnRoot(letted, lca, sameLettedRefs, currentRoot) {
-    const lettedHash = letted.hash;
-    let parentNode = lca.parent;
-    const parentNodeDirectChild = lca;
-    // add 1 to every var's DeBruijn that accesses stuff outside the parent node
-    // not including the `parentNode` node
-    // since the new function introdcued substituting the letted term
-    // is added inside the `parentNode` node
-    incrementUnboundDbns(parentNodeDirectChild, 
-    // `shouldNotModifyLetted` arg (given the hash returns `true` if it should NOT modify the term)
-    ({ hash }) => equalIrHash(hash, lettedHash));
-    // now we replace
-    const lettedValue = letted.value; //.clone();
-    // no need to modify letted value dbns, since closed
-    // modifyValueToLetDbns( lettedValue, getDiffDbn( letted, parentNode ) );
-    const newNode = new IRApp(new IRFunc(1, parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
-    // replace child with new node
-    if (parentNode) {
-        _modifyChildFromTo(parentNode, parentNodeDirectChild, newNode);
-    }
-    else {
-        currentRoot = newNode;
-    }
-    for (const ref of sameLettedRefs) {
-        _modifyChildFromTo(ref.parent, ref, new IRVar(getDebruijnInTerm(parentNodeDirectChild, ref)));
-    }
-    return currentRoot;
-}

package/dist/IR/toUPLC/subRoutines/handleRecursiveTerms.d.ts

@@ -1,3 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export declare function handleRecursiveTerms(term: IRTerm): void;
-export declare function handleRootRecursiveTerm(term: IRTerm): IRTerm;

package/dist/IR/toUPLC/subRoutines/handleRecursiveTerms.js

@@ -1,32 +0,0 @@
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-import { IRSelfCall } from "../../IRNodes/IRSelfCall.js";
-import { IRVar } from "../../IRNodes/IRVar.js";
-import { getChildren } from "../../tree_utils/getChildren.js";
-import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
-export function handleRecursiveTerms(term) {
-    if (term instanceof IRRecursive) {
-        const bodyPtr = term.body;
-        _modifyChildFromTo(term.parent, term, new IRApp(new IRHoisted(new IRFunc(1, new IRApp(new IRVar(0), new IRVar(0)))), new IRFunc(1, bodyPtr)));
-        handleRecursiveTerms(bodyPtr);
-        return;
-    }
-    if (term instanceof IRSelfCall) {
-        _modifyChildFromTo(term.parent, term, new IRApp(new IRVar(term.dbn), new IRVar(term.dbn)));
-        return;
-    }
-    getChildren(term).forEach(handleRecursiveTerms);
-}
-export function handleRootRecursiveTerm(term) {
-    if (term instanceof IRRecursive) {
-        const bodyPtr = term.body;
-        const newRoot = new IRApp(new IRHoisted(new IRFunc(1, new IRApp(new IRVar(0), new IRVar(0)))), new IRFunc(1, bodyPtr));
-        handleRecursiveTerms(bodyPtr);
-        return newRoot;
-    }
-    // else
-    handleRecursiveTerms(term);
-    return term;
-}

package/dist/IR/toUPLC/subRoutines/hoistForcedNatives.d.ts

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

package/dist/IR/toUPLC/subRoutines/hoistForcedNatives.js

@@ -1,58 +0,0 @@
-import { IRApp, IRVar } from "../../IRNodes/index.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRNative } from "../../IRNodes/IRNative/index.js";
-import { IRNativeTag } from "../../IRNodes/IRNative/IRNativeTag.js";
-import { isForcedNative } from "../../IRNodes/IRNative/isForcedNative.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-import { isIRParentTerm } from "../../utils/isIRParentTerm.js";
-import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
-import { iterTree } from "../_internal/iterTree.js";
-import { sanifyTree } from "./sanifyTree.js";
-export function hoistForcedNatives(term) {
-    if (!isIRParentTerm(term))
-        return term;
-    const toHoist = {
-        [IRNativeTag.strictIfThenElse]: [],
-        [IRNativeTag.chooseUnit]: [],
-        [IRNativeTag.trace]: [],
-        [IRNativeTag.mkCons]: [],
-        [IRNativeTag.headList]: [],
-        [IRNativeTag.tailList]: [],
-        [IRNativeTag.nullList]: [],
-        [IRNativeTag.chooseData]: [],
-        [IRNativeTag.fstPair]: [],
-        [IRNativeTag.sndPair]: [],
-        [IRNativeTag.strictChooseList]: [],
-    };
-    sanifyTree(term);
-    // console.log( showIRText( term ) );
-    // collect all forced natives
-    iterTree(term, (node) => {
-        if (isForcedNative(node)) {
-            toHoist[node.tag].push(node);
-        }
-    });
-    const tags = Object.keys(toHoist);
-    for (const tagStr of tags) {
-        const tag = Number(tagStr);
-        const nodes = toHoist[tag];
-        if (nodes.length <= 0)
-            continue; // also single use (might be inside loop)
-        for (const node of nodes) {
-            _modifyChildFromTo(node.parent, node, new IRVar(getDbnToRoot(node)));
-        }
-        term = new IRApp(new IRFunc(1, term), new IRNative(tag));
-    }
-    return term;
-}
-function getDbnToRoot(node) {
-    let dbn = 0; // if no IRFunc is found, the node is at dbn 0 (the new func will be added)
-    let current = node;
-    while (current) {
-        if (current instanceof IRFunc ||
-            current instanceof IRRecursive)
-            dbn += current.arity;
-        current = current.parent;
-    }
-    return dbn;
-}

package/dist/IR/toUPLC/subRoutines/inlineSingleUseApplications.d.ts

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

package/dist/IR/toUPLC/subRoutines/inlineSingleUseApplications.js

@@ -1,12 +0,0 @@
-import { IRVar } from "../../IRNodes/IRVar.js";
-import { iterTree } from "../_internal/iterTree.js";
-function hasAtLeastNVarsAtDbn(term, baseDbn = 0) {
-    let n = 0;
-    iterTree(term, (node, dbn) => {
-        if (node instanceof IRVar && node.dbn === baseDbn + dbn)
-            n++;
-    }, undefined, // shouldSkipNode
-    () => n > 1 // shouldExit
-    );
-    return n > 1;
-}

package/dist/IR/toUPLC/subRoutines/markRecursiveHoistsAsForced.d.ts

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

package/dist/IR/toUPLC/subRoutines/markRecursiveHoistsAsForced.js

@@ -1,82 +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 markRecursiveHoistsAsForced(_term) {
-    const stack = [{ term: _term, isInRecursiveTerm: false }];
-    while (stack.length > 0) {
-        const { term: t, isInRecursiveTerm, isIRAppArg } = stack.pop();
-        if (t instanceof IRApp) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
-            stack.push({ term: t.arg, isIRAppArg: true, isInRecursiveTerm }, { term: t.fn, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
-            stack.push(...Array.from(t.fields)
-                .map((f, i) => ({
-                term: f,
-                isIRAppArg: i > 0,
-                isInRecursiveTerm
-            })));
-            continue;
-        }
-        if (t instanceof IRCase) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
-            stack.push({
-                term: t.constrTerm,
-                isIRAppArg: false,
-                isInRecursiveTerm
-            }, ...Array.from(t.continuations)
-                .map(cont => ({
-                term: cont,
-                isIRAppArg: true,
-                isInRecursiveTerm
-            })));
-            continue;
-        }
-        if (t instanceof IRHoisted ||
-            t instanceof IRLetted) {
-            if (isInRecursiveTerm) {
-                t.meta.forceHoist = true;
-                // don't push anything to the stack
-                // hoisted values are handled normally
-                continue;
-            }
-            // otherwhise check in values too
-            else if (t instanceof IRLetted) {
-                stack.push({ term: t.value, isInRecursiveTerm });
-                continue;
-            }
-            else if (t instanceof IRHoisted) {
-                stack.push({ term: t.hoisted, isInRecursiveTerm });
-                continue;
-            }
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, isInRecursiveTerm: true });
-            continue;
-        }
-        const tsEnsureExsaustiveCheck = t;
-    }
-}

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/expandFuncsAndReturnRoot.d.ts

@@ -1,4 +0,0 @@
-import { IRFunc } from "../../../IRNodes/IRFunc.js";
-import { IRTerm } from "../../../IRTerm.js";
-export declare function getExpandedIRFunc(body: IRTerm, arity: number): IRFunc;
-export declare function expandFuncsAndReturnRoot(root: IRTerm): IRTerm;

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/expandFuncsAndReturnRoot.js

@@ -1,68 +0,0 @@
-import { IRConstr } from "../../../IRNodes/index.js";
-import { IRApp } from "../../../IRNodes/IRApp.js";
-import { IRCase } from "../../../IRNodes/IRCase.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";
-import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
-import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
-export function getExpandedIRFunc(body, arity) {
-    body = new IRFunc(1, body);
-    while (--arity > 0) {
-        body = new IRFunc(1, body);
-    }
-    return body;
-    // if( arity === 1 ) return new IRFunc( 1, body );
-    // return new IRFunc( 1, getExpandedIRFunc( body, arity - 1 ) );
-}
-export function expandFuncsAndReturnRoot(root) {
-    const stack = [root];
-    while (stack.length > 0) {
-        const t = stack.pop();
-        if (t instanceof IRFunc) {
-            // whatever happens we continue from the body
-            stack.push(t.body);
-            // all good
-            if (t.arity <= 1)
-                continue;
-            const expanded = getExpandedIRFunc(t.body, t.arity);
-            if (t.parent) {
-                _modifyChildFromTo(t.parent, t, expanded);
-            }
-            else {
-                root = expanded;
-            }
-            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 IRRecursive ||
-            t instanceof IRHoisted ||
-            t instanceof IRLetted ||
-            t instanceof IRSelfCall) {
-            throw new Error("Unexpected term while performing uplc optimizations");
-        }
-    }
-    return root;
-}

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

@@ -1,5 +0,0 @@
-import { IRTerm } from "../../../IRTerm.js";
-import { CompilerOptions } from "../../CompilerOptions.js";
-export declare function performUplcOptimizationsAndReturnRoot(root: IRTerm, options: CompilerOptions): IRTerm;
-/** @experimental still can't figure how to make it work */
-export declare function groupIndipendentLets(term: IRTerm, dbn: number): [args: IRTerm[], body: IRTerm];