@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

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

@@ -1,80 +0,0 @@
-import { UPLCVersion } from "@harmoniclabs/uplc";
-export interface CompilerUplcOptimizations {
-    /**
-     *
-     **/
-    groupApplications: boolean;
-    /**
-     **/
-    inlineSingleUse: boolean;
-    /**
-     **/
-    simplifyWrappedPartialFuncApps: boolean;
-    /**
-     *
-     **/
-    removeForceDelay: boolean;
-}
-export declare const productionUplcOptimizations: CompilerUplcOptimizations;
-export declare const debugUplcOptimizations: CompilerUplcOptimizations;
-export declare const defaultUplcOptimizations: CompilerUplcOptimizations;
-export declare function isDebugUplcOptimizations(options?: Partial<CompilerUplcOptimizations>): boolean;
-export declare function completeUplcOptimizations(options: Partial<CompilerUplcOptimizations>, complete?: CompilerUplcOptimizations): CompilerUplcOptimizations;
-export interface CompilerOptions {
-    /**
-     * path to the entry file
-     */
-    readonly entry: string;
-    /**
-     * path of the root of the project
-     */
-    readonly root: string;
-    /**
-     * path to the output directory
-     */
-    readonly outDir: string;
-    /**
-     * uplc version (encoded in the script)
-     */
-    targetUplcVersion: UPLCVersion;
-    /**
-     * @todo TODO
-     *
-     * @default true
-     *
-     * set to `false` only for debugging purposes
-     **/
-    removeTraces: boolean;
-    /**
-     * @todo TODO
-     *
-     * if `true` replaces all `IRHoisted` with `IRLetted`
-     *
-     * handling letted terms is more expansive than hoisted terms
-     * because hoisted (since closed terms) are blindly added as roots of the script
-     *
-     * however this approach impacts the "script startup cost" considerably
-     * esxpecially for scripts with different branches (eg. multi purpose scripts)
-     * where some hoisted may never be used in some branches,
-     * but still are added to the "initialization cost"
-     *
-     * on the other hand, handling letted instead of hoisted may impact compliation time
-     *
-     * for this reason it is best to set this option to `true` only for production
-     **/
-    delayHoists: boolean;
-    /**
-     *
-     **/
-    uplcOptimizations: Partial<CompilerUplcOptimizations>;
-    /**
-     *
-     **/
-    addMarker: boolean;
-}
-export declare const extremeOptions: CompilerOptions;
-export declare const productionOptions: CompilerOptions;
-export declare const debugOptions: CompilerOptions;
-export declare const defaultOptions: CompilerOptions;
-export declare const defulatCompilerOptions: CompilerOptions;
-export declare function completeCompilerOptions(options: Partial<CompilerOptions>, complete?: CompilerOptions): CompilerOptions;

package/dist/IR/toUPLC/CompilerOptions.js

@@ -1,98 +0,0 @@
-import { isObject } from "@harmoniclabs/obj-utils";
-import { defaultUplcVersion, UPLCVersion } from "@harmoniclabs/uplc";
-export const productionUplcOptimizations = Object.freeze({
-    groupApplications: true,
-    inlineSingleUse: true,
-    simplifyWrappedPartialFuncApps: true,
-    removeForceDelay: true
-});
-export const debugUplcOptimizations = Object.freeze({
-    groupApplications: false,
-    inlineSingleUse: false,
-    simplifyWrappedPartialFuncApps: false,
-    removeForceDelay: true
-});
-export const defaultUplcOptimizations = productionUplcOptimizations;
-export function isDebugUplcOptimizations(options = {}) {
-    return Object.keys(debugUplcOptimizations)
-        .every((key) => {
-        // keys to ignore
-        if (key === "removeForceDelay")
-            return true;
-        return options[key] === debugUplcOptimizations[key];
-    });
-}
-export function completeUplcOptimizations(options, complete = defaultUplcOptimizations) {
-    if (!isObject(options))
-        return { ...defaultUplcOptimizations };
-    return {
-        groupApplications: options.groupApplications ?? complete.groupApplications,
-        inlineSingleUse: options.inlineSingleUse ?? complete.inlineSingleUse,
-        simplifyWrappedPartialFuncApps: options.simplifyWrappedPartialFuncApps ?? complete.simplifyWrappedPartialFuncApps,
-        removeForceDelay: options.removeForceDelay ?? complete.removeForceDelay
-    };
-}
-export const extremeOptions = Object.freeze({
-    entry: "./src/index.pebble",
-    root: ".",
-    outDir: "./out",
-    targetUplcVersion: defaultUplcVersion,
-    removeTraces: true,
-    delayHoists: true,
-    uplcOptimizations: productionUplcOptimizations,
-    addMarker: true
-});
-export const productionOptions = Object.freeze({
-    entry: "./src/index.pebble",
-    root: ".",
-    outDir: "./out",
-    targetUplcVersion: defaultUplcVersion,
-    removeTraces: true,
-    delayHoists: true,
-    uplcOptimizations: productionUplcOptimizations,
-    addMarker: true
-});
-export const debugOptions = Object.freeze({
-    entry: "./src/index.pebble",
-    root: ".",
-    outDir: "./out",
-    targetUplcVersion: defaultUplcVersion,
-    removeTraces: false,
-    delayHoists: false,
-    uplcOptimizations: debugUplcOptimizations,
-    addMarker: false
-});
-export const defaultOptions = productionOptions;
-export const defulatCompilerOptions = defaultOptions;
-export function completeCompilerOptions(options, complete = defaultOptions) {
-    let targetUplcVersion = options.targetUplcVersion instanceof UPLCVersion ? complete.targetUplcVersion : defaultUplcVersion;
-    complete = {
-        ...defaultOptions,
-        ...complete
-    };
-    let uplcOptimizations = options.uplcOptimizations;
-    if (typeof options.uplcOptimizations === "boolean") {
-        if (options.uplcOptimizations) {
-            uplcOptimizations = {
-                ...productionUplcOptimizations,
-                ...uplcOptimizations
-            };
-        }
-        else {
-            uplcOptimizations = {
-                ...debugUplcOptimizations,
-                ...uplcOptimizations,
-            };
-        }
-    }
-    // console.log( "uplcOptimizations", uplcOptimizations );
-    // console.log( "completeUplcOptimizations( uplcOptimizations )",completeUplcOptimizations( uplcOptimizations ))
-    return {
-        ...complete,
-        targetUplcVersion,
-        removeTraces: options.removeTraces ?? complete.removeTraces,
-        delayHoists: options.delayHoists ?? complete.delayHoists,
-        uplcOptimizations: completeUplcOptimizations(uplcOptimizations),
-        addMarker: options.addMarker ?? complete.addMarker
-    };
-}

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

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

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

@@ -1,58 +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";
-import { mapArrayLike } from "../../IRNodes/utils/mapArrayLike.js";
-import { defineDepth } from "./depth.js";
-export function _addDepths(_term, initialDepth = 0) {
-    const stack = [defineDepth(_term, initialDepth)];
-    while (stack.length > 0) {
-        const t = stack.pop();
-        if (t instanceof IRApp) {
-            stack.push(defineDepth(t.fn, t.depth + 1), defineDepth(t.arg, t.depth + 1));
-            continue;
-        }
-        if (t instanceof IRCase) {
-            const nextDepth = t.depth + 1;
-            stack.push(defineDepth(t.constrTerm, nextDepth), ...mapArrayLike(t.continuations, (continuation) => defineDepth(continuation, nextDepth)));
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...mapArrayLike(t.fields, (field) => defineDepth(field, t.depth + 1)));
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(defineDepth(t.delayed, t.depth + 1));
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(defineDepth(t.forced, t.depth + 1));
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(defineDepth(t.body, t.depth + 1));
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(defineDepth(t.body, t.depth + 1));
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            // 0 because hoisted are closed
-            // for hoisted we keep track of the depth inside the term
-            stack.push(defineDepth(t.hoisted, 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(defineDepth(t.value, 0));
-            continue;
-        }
-    }
-}

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

@@ -1,9 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-import { UPLCTerm } from "@harmoniclabs/uplc";
-export type RawSrcMap = {
-    [node_index: number]: string;
-};
-export declare function _irToUplc(ir: IRTerm, srcmap?: RawSrcMap | undefined, node_index?: number): {
-    term: UPLCTerm;
-    max_idx: number;
-};

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

@@ -1,156 +0,0 @@
-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 { nativeTagToString } from "../../IRNodes/IRNative/IRNativeTag.js";
-import { IRVar } from "../../IRNodes/IRVar.js";
-import { showIR } from "../../utils/showIR.js";
-import { IRError } from "../../IRNodes/IRError.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { UPLCVar, Lambda, Application, Builtin, ErrorUPLC, Force, Delay, Constr, Case } from "@harmoniclabs/uplc";
-import { IRConstr } from "../../IRNodes/IRConstr.js";
-import { IRCase } from "../../IRNodes/IRCase.js";
-import { irHashToHex } from "../../IRHash.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-import { IRSelfCall } from "../../IRNodes/IRSelfCall.js";
-export function _irToUplc(ir, srcmap = undefined, node_index = 0) {
-    if (!(ir instanceof IRConst)) {
-        // console.log("_irToUplc", ir, node_index, Date.now());
-    }
-    else {
-        // if( ir.parent )
-        // {
-        //     console.log(ir.parent ? Object.getPrototypeOf( ir.parent ).constructor.name : undefined, Date.now() );
-        // }
-        // else
-        // {
-        //     console.log( Error().stack );
-        // }
-    }
-    if (ir instanceof IRConst) {
-        return {
-            term: ir.toUPLC(),
-            max_idx: node_index
-        };
-    }
-    if (ir instanceof IRVar)
-        return {
-            term: new UPLCVar(ir.dbn),
-            max_idx: node_index
-        };
-    if (ir instanceof IRFunc) {
-        const { term: body, max_idx } = _irToUplc(ir.body, srcmap, node_index);
-        let lam = new Lambda(body);
-        for (let i = 1; i < ir.arity; i++) {
-            lam = new Lambda(lam);
-        }
-        return {
-            term: lam,
-            max_idx
-        };
-    }
-    if (ir instanceof IRRecursive) {
-        throw new Error("Can't convert 'IRRecursive' to valid UPLC;" +
-            "IRRecursive are expected to be converted before calling '_irToUplc'");
-    }
-    if (ir instanceof IRSelfCall) {
-        throw new Error("Can't convert 'IRSelfCall' to valid UPLC;" +
-            "IRSelfCall are expected to be converted before calling '_irToUplc'");
-    }
-    if (ir instanceof IRApp) {
-        const { term: fn, max_idx: fn_max_idx } = _irToUplc(ir.fn, srcmap, node_index + 1);
-        const { term: arg, max_idx: arg_max_idx } = _irToUplc(ir.arg, srcmap, fn_max_idx + 1);
-        let src = ir.meta.__src__;
-        if (srcmap && typeof src === "string") {
-            srcmap[node_index] = adaptSrcString(src);
-        }
-        return {
-            term: new Application(fn, arg),
-            max_idx: arg_max_idx
-        };
-    }
-    if (ir instanceof IRNative) {
-        if (ir.tag < 0)
-            throw new Error("Can't translate '" + nativeTagToString(ir.tag) + "' 'IRNative' to 'UPLCBuiltin'");
-        return {
-            term: new Builtin(ir.tag),
-            max_idx: node_index
-        };
-    }
-    if (ir instanceof IRLetted) {
-        throw new Error("Can't convert 'IRLetted' to valid UPLC");
-    }
-    if (ir instanceof IRHoisted) {
-        // return this.hoisted.toUPLC();
-        throw new Error("Can't convert 'IRHoisted' to valid UPLC;" +
-            "\nhoisted hash was: " + irHashToHex(ir.hash) +
-            "\nhoisted term was: " + showIR(ir.hoisted).text);
-    }
-    if (ir instanceof IRError) {
-        if (typeof ir.addInfos.__src__ === "string" && srcmap) {
-            srcmap[node_index] = adaptSrcString(ir.addInfos.__src__);
-        }
-        return {
-            term: new ErrorUPLC(ir.msg, ir.addInfos),
-            max_idx: node_index
-        };
-    }
-    if (ir instanceof IRForced) {
-        const { term: toForce, max_idx } = _irToUplc(ir.forced, srcmap, node_index);
-        return {
-            term: new Force(toForce),
-            max_idx
-        };
-    }
-    if (ir instanceof IRDelayed) {
-        const { term: toDelay, max_idx } = _irToUplc(ir.delayed, srcmap, node_index);
-        return {
-            term: new Delay(toDelay),
-            max_idx
-        };
-    }
-    if (ir instanceof IRConstr) {
-        if (ir.fields.length === 0) {
-            return {
-                term: new Constr(ir.index, []),
-                max_idx: node_index + 1
-            };
-        }
-        const fields = Array.from(ir.fields)
-            .slice(1)
-            .reduce((accum, field, i) => {
-            accum.push(_irToUplc(field, srcmap, accum[i].max_idx + 1));
-            return accum;
-        }, [_irToUplc(ir.fields[0], srcmap, node_index)]);
-        return {
-            term: new Constr(ir.index, fields.map(({ term }) => term)),
-            max_idx: fields[fields.length - 1].max_idx
-        };
-    }
-    if (ir instanceof IRCase) {
-        const { term: constrTerm, max_idx } = _irToUplc(ir.constrTerm, srcmap, node_index);
-        const conts = Array.from(ir.continuations)
-            .slice(1)
-            .reduce((accum, cont, i) => {
-            accum.push(_irToUplc(cont, srcmap, accum[i].max_idx + 1));
-            return accum;
-        }, [_irToUplc(ir.continuations[0], srcmap, max_idx + 1)]);
-        return {
-            term: new Case(constrTerm, conts.map(({ term }) => term)),
-            max_idx: conts[conts.length - 1].max_idx
-        };
-    }
-    throw new Error("unknown IR term calling '_irToUplc'");
-}
-function adaptSrcString(src) {
-    // "   at $ (some/path/to/src.ts:line:column)" -> "some/path/to/src.ts:line:column"
-    let idx = src.indexOf("(");
-    src = idx >= 0 ? src.slice(idx + 1, src.length - 1) : src;
-    // "   at some/path/to/src.ts:line:column" -> "some/path/to/src.ts:line:column"
-    idx = src.indexOf("at ");
-    src = idx >= 0 ? src.slice(idx + 3) : src;
-    return src;
-}

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

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

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

@@ -1,12 +0,0 @@
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRNative } from "../../IRNodes/IRNative/index.js";
-import { _modifyChildFromTo } from "./_modifyChildFromTo.js";
-import { iterTree } from "./iterTree.js";
-export function _makeAllNegativeNativesHoisted(term) {
-    iterTree(term, elem => {
-        if (elem instanceof IRNative && !(elem.parent instanceof IRHoisted)) {
-            _modifyChildFromTo(elem.parent, elem, new IRHoisted(elem));
-            return true;
-        }
-    });
-}

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

@@ -1,10 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-import { IRParentTerm } from "../../utils/isIRParentTerm.js";
-import { IRHash } from "../../IRHash.js";
-/**
- *
- * @param parent node to modify the child of
- * @param currentChild mainly passed to distinguish in case of `IRApp`
- * @param newChild new node's child
- */
-export declare function _modifyChildFromTo(parent: IRParentTerm | undefined, currentChild: IRTerm | IRHash, newChild: IRTerm): void;

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

@@ -1,141 +0,0 @@
-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 { IRCase } from "../../IRNodes/IRCase.js";
-import { equalIrHash, irHashToHex, isIRHash } from "../../IRHash.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-import { isIRTerm } from "../../utils/isIRTerm.js";
-/**
- *
- * @param parent node to modify the child of
- * @param currentChild mainly passed to distinguish in case of `IRApp`
- * @param newChild new node's child
- */
-export function _modifyChildFromTo(parent, currentChild, newChild) {
-    if (parent === undefined) {
-        throw new Error("'_modifyChildFromTo' received an undefined parent, possibly root");
-    }
-    if (
-    // currentChild has parent property
-    isIRTerm(currentChild) &&
-        // and is not (already) undefined
-        currentChild.parent !== undefined &&
-        // and the `parent` passed to the function is the parent of the `currentChild`
-        currentChild.parent === parent &&
-        // and child to be modified is not the same object
-        currentChild !== newChild) {
-        // we are modifying the child
-        // so we remove parent the reference
-        currentChild.parent = undefined;
-    }
-    // DO NOT USE **ONLY** SHALLOW EQUALITY
-    // child might be cloned
-    // however delay hash computation until needed
-    let _childHash;
-    const currChildHash = () => {
-        if (isIRHash(_childHash))
-            return _childHash;
-        _childHash = isIRHash(currentChild) ? currentChild : currentChild.hash;
-        return _childHash;
-    };
-    if (parent instanceof IRApp) {
-        // check the argument first as it is more likely to have a smaller tree
-        if (currentChild === parent.arg) {
-            parent.arg = newChild;
-        }
-        else if (currentChild === parent.fn) {
-            parent.fn = newChild;
-        }
-        else if (equalIrHash(parent.arg.hash, currChildHash())) {
-            parent.arg = newChild;
-        }
-        else if (equalIrHash(parent.fn.hash, currChildHash())) {
-            parent.fn = newChild;
-        }
-        else {
-            throw new Error("unknown 'IRApp' child to modify; given child to modify hash: " +
-                irHashToHex(currChildHash()) +
-                "; function child hash: " + irHashToHex(parent.fn.hash) +
-                "; argument child hash: " + irHashToHex(parent.arg.hash));
-        }
-        return;
-    }
-    else if (parent instanceof IRConstr) {
-        let foundChild = false;
-        for (let i = 0; i < parent.fields.length; i++) {
-            const field = parent.fields[i];
-            if (field === currentChild) {
-                parent.fields[i] = newChild;
-                foundChild = true;
-                break;
-            }
-        }
-        if (foundChild)
-            return;
-        for (let i = 0; i < parent.fields.length; i++) {
-            const field = parent.fields[i];
-            if (equalIrHash(field.hash, currChildHash())) {
-                parent.fields[i] = newChild;
-                break;
-            }
-        }
-        return;
-    }
-    else if (parent instanceof IRCase) {
-        if (parent.constrTerm === currentChild) {
-            parent.constrTerm = newChild;
-            return;
-        }
-        let foundChild = false;
-        for (let i = 0; i < parent.continuations.length; i++) {
-            const field = parent.continuations[i];
-            if (field === currentChild) {
-                parent.continuations[i] = newChild;
-                foundChild = true;
-                break;
-            }
-        }
-        if (foundChild)
-            return;
-        if (equalIrHash(currChildHash(), parent.constrTerm.hash)) {
-            parent.constrTerm = newChild;
-            return;
-        }
-        for (let i = 0; i < parent.continuations.length; i++) {
-            const field = parent.continuations[i];
-            if (equalIrHash(field.hash, currChildHash())) {
-                parent.continuations[i] = newChild;
-                break;
-            }
-        }
-        return;
-    }
-    if (parent instanceof IRDelayed) {
-        parent.delayed = newChild;
-        return;
-    }
-    if (parent instanceof IRForced) {
-        parent.forced = newChild;
-        return;
-    }
-    if (parent instanceof IRFunc) {
-        parent.body = newChild;
-        return;
-    }
-    if (parent instanceof IRRecursive) {
-        parent.body = newChild;
-        return;
-    }
-    if (parent instanceof IRHoisted) {
-        parent.hoisted = newChild;
-        return;
-    }
-    if (parent instanceof IRLetted) {
-        parent.value = newChild;
-        return;
-    }
-}

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

@@ -1,5 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export type IRTermWithDepth = IRTerm & {
-    depth: number;
-};
-export declare function defineDepth(term: IRTerm, depth: number): IRTermWithDepth;

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

@@ -1,8 +0,0 @@
-export function defineDepth(term, depth) {
-    return Object.defineProperty(term, "depth", {
-        value: depth,
-        writable: true,
-        enumerable: true,
-        configurable: false
-    });
-}

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

@@ -1,3 +0,0 @@
-import { IRTerm } from "../../IRTerm.js";
-export declare function findAll(term: IRTerm, predicate: (elem: IRTerm) => boolean): IRTerm[];
-export declare function findAllNoHoisted(term: IRTerm, predicate: (elem: IRTerm) => boolean): IRTerm[];