@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

package/dist/tokenizer/Token.js

@@ -78,129 +78,139 @@ export var Token;
     Token[Token["Test"] = 38] = "Test";
     Token[Token["Fail"] = 39] = "Fail";
     Token[Token["Assert"] = 40] = "Assert";
+    // contract keywords
+    Token[Token["Contract"] = 41] = "Contract";
+    Token[Token["Param"] = 42] = "Param";
+    Token[Token["Spend"] = 43] = "Spend";
+    Token[Token["Mint"] = 44] = "Mint";
+    Token[Token["Certify"] = 45] = "Certify";
+    Token[Token["Withdraw"] = 46] = "Withdraw";
+    Token[Token["Propose"] = 47] = "Propose";
+    Token[Token["Vote"] = 48] = "Vote";
+    Token[Token["Context"] = 49] = "Context";
     // punctuation
     /** `{` */
-    Token[Token["OpenBrace"] = 41] = "OpenBrace";
+    Token[Token["OpenBrace"] = 50] = "OpenBrace";
     /** `}` */
-    Token[Token["CloseBrace"] = 42] = "CloseBrace";
-    Token[Token["OpenParen"] = 43] = "OpenParen";
-    Token[Token["CloseParen"] = 44] = "CloseParen";
+    Token[Token["CloseBrace"] = 51] = "CloseBrace";
+    Token[Token["OpenParen"] = 52] = "OpenParen";
+    Token[Token["CloseParen"] = 53] = "CloseParen";
     /** `[` */
-    Token[Token["OpenBracket"] = 45] = "OpenBracket";
+    Token[Token["OpenBracket"] = 54] = "OpenBracket";
     /** `]` */
-    Token[Token["CloseBracket"] = 46] = "CloseBracket";
+    Token[Token["CloseBracket"] = 55] = "CloseBracket";
     /** `.` */
-    Token[Token["Dot"] = 47] = "Dot";
+    Token[Token["Dot"] = 56] = "Dot";
     /** `...` */
-    Token[Token["Dot_Dot_Dot"] = 48] = "Dot_Dot_Dot";
+    Token[Token["Dot_Dot_Dot"] = 57] = "Dot_Dot_Dot";
     /** `;` */
-    Token[Token["Semicolon"] = 49] = "Semicolon";
+    Token[Token["Semicolon"] = 58] = "Semicolon";
     /** `,` */
-    Token[Token["Comma"] = 50] = "Comma";
+    Token[Token["Comma"] = 59] = "Comma";
     /** `<` */
-    Token[Token["LessThan"] = 51] = "LessThan";
+    Token[Token["LessThan"] = 60] = "LessThan";
     /** `>` */
-    Token[Token["GreaterThan"] = 52] = "GreaterThan";
+    Token[Token["GreaterThan"] = 61] = "GreaterThan";
     /** `<=` */
-    Token[Token["LessThan_Equals"] = 53] = "LessThan_Equals";
+    Token[Token["LessThan_Equals"] = 62] = "LessThan_Equals";
     /** `>=` */
-    Token[Token["GreaterThan_Equals"] = 54] = "GreaterThan_Equals";
+    Token[Token["GreaterThan_Equals"] = 63] = "GreaterThan_Equals";
     /** `==` */
-    Token[Token["Equals_Equals"] = 55] = "Equals_Equals";
+    Token[Token["Equals_Equals"] = 64] = "Equals_Equals";
     /** `!=` */
-    Token[Token["Exclamation_Equals"] = 56] = "Exclamation_Equals";
+    Token[Token["Exclamation_Equals"] = 65] = "Exclamation_Equals";
     /** `===` */
-    Token[Token["Equals_Equals_Equals"] = 57] = "Equals_Equals_Equals";
+    Token[Token["Equals_Equals_Equals"] = 66] = "Equals_Equals_Equals";
     /** `!==` */
-    Token[Token["Exclamation_Equals_Equals"] = 58] = "Exclamation_Equals_Equals";
+    Token[Token["Exclamation_Equals_Equals"] = 67] = "Exclamation_Equals_Equals";
     /** `=>` */
-    Token[Token["FatArrow"] = 59] = "FatArrow";
+    Token[Token["FatArrow"] = 68] = "FatArrow";
     /** `+` */
-    Token[Token["Plus"] = 60] = "Plus";
+    Token[Token["Plus"] = 69] = "Plus";
     /** `-` */
-    Token[Token["Minus"] = 61] = "Minus";
+    Token[Token["Minus"] = 70] = "Minus";
     /** `**` */
-    Token[Token["Asterisk_Asterisk"] = 62] = "Asterisk_Asterisk";
+    Token[Token["Asterisk_Asterisk"] = 71] = "Asterisk_Asterisk";
     /** `*` */
-    Token[Token["Asterisk"] = 63] = "Asterisk";
+    Token[Token["Asterisk"] = 72] = "Asterisk";
     /** `/` */
-    Token[Token["Slash"] = 64] = "Slash";
+    Token[Token["Slash"] = 73] = "Slash";
     /** `%` */
-    Token[Token["Percent"] = 65] = "Percent";
+    Token[Token["Percent"] = 74] = "Percent";
     /** `++` */
-    Token[Token["Plus_Plus"] = 66] = "Plus_Plus";
+    Token[Token["Plus_Plus"] = 75] = "Plus_Plus";
     /** `--` */
-    Token[Token["Minus_Minus"] = 67] = "Minus_Minus";
+    Token[Token["Minus_Minus"] = 76] = "Minus_Minus";
     /** `<<` */
-    Token[Token["LessThan_LessThan"] = 68] = "LessThan_LessThan";
+    Token[Token["LessThan_LessThan"] = 77] = "LessThan_LessThan";
     /** `>>` */
-    Token[Token["GreaterThan_GreaterThan"] = 69] = "GreaterThan_GreaterThan";
+    Token[Token["GreaterThan_GreaterThan"] = 78] = "GreaterThan_GreaterThan";
     /** `>>>` */
-    Token[Token["GreaterThan_GreaterThan_GreaterThan"] = 70] = "GreaterThan_GreaterThan_GreaterThan";
+    Token[Token["GreaterThan_GreaterThan_GreaterThan"] = 79] = "GreaterThan_GreaterThan_GreaterThan";
     /** `+` */
-    Token[Token["Ampersand"] = 71] = "Ampersand";
+    Token[Token["Ampersand"] = 80] = "Ampersand";
     /** `|` */
-    Token[Token["Bar"] = 72] = "Bar";
+    Token[Token["Bar"] = 81] = "Bar";
     /** `^` */
-    Token[Token["Caret"] = 73] = "Caret";
+    Token[Token["Caret"] = 82] = "Caret";
     /** `!` */
-    Token[Token["Exclamation"] = 74] = "Exclamation";
+    Token[Token["Exclamation"] = 83] = "Exclamation";
     /** `~` */
-    Token[Token["Tilde"] = 75] = "Tilde";
+    Token[Token["Tilde"] = 84] = "Tilde";
     /** `&&` */
-    Token[Token["Ampersand_Ampersand"] = 76] = "Ampersand_Ampersand";
+    Token[Token["Ampersand_Ampersand"] = 85] = "Ampersand_Ampersand";
     /** `||` */
-    Token[Token["Bar_Bar"] = 77] = "Bar_Bar";
+    Token[Token["Bar_Bar"] = 86] = "Bar_Bar";
     /** `?` */
-    Token[Token["Question"] = 78] = "Question";
+    Token[Token["Question"] = 87] = "Question";
     /** `:` */
-    Token[Token["Colon"] = 79] = "Colon";
+    Token[Token["Colon"] = 88] = "Colon";
     /** `=` */
-    Token[Token["Equals"] = 80] = "Equals";
-    Token[Token["Plus_Equals"] = 81] = "Plus_Equals";
-    Token[Token["Minus_Equals"] = 82] = "Minus_Equals";
-    Token[Token["Asterisk_Equals"] = 83] = "Asterisk_Equals";
-    Token[Token["Asterisk_Asterisk_Equals"] = 84] = "Asterisk_Asterisk_Equals";
-    Token[Token["Slash_Equals"] = 85] = "Slash_Equals";
-    Token[Token["Percent_Equals"] = 86] = "Percent_Equals";
-    Token[Token["LessThan_LessThan_Equals"] = 87] = "LessThan_LessThan_Equals";
-    Token[Token["GreaterThan_GreaterThan_Equals"] = 88] = "GreaterThan_GreaterThan_Equals";
-    Token[Token["GreaterThan_GreaterThan_GreaterThan_Equals"] = 89] = "GreaterThan_GreaterThan_GreaterThan_Equals";
-    Token[Token["Ampersand_Equals"] = 90] = "Ampersand_Equals";
-    Token[Token["Bar_Equals"] = 91] = "Bar_Equals";
-    Token[Token["Caret_Equals"] = 92] = "Caret_Equals";
-    Token[Token["At"] = 93] = "At";
+    Token[Token["Equals"] = 89] = "Equals";
+    Token[Token["Plus_Equals"] = 90] = "Plus_Equals";
+    Token[Token["Minus_Equals"] = 91] = "Minus_Equals";
+    Token[Token["Asterisk_Equals"] = 92] = "Asterisk_Equals";
+    Token[Token["Asterisk_Asterisk_Equals"] = 93] = "Asterisk_Asterisk_Equals";
+    Token[Token["Slash_Equals"] = 94] = "Slash_Equals";
+    Token[Token["Percent_Equals"] = 95] = "Percent_Equals";
+    Token[Token["LessThan_LessThan_Equals"] = 96] = "LessThan_LessThan_Equals";
+    Token[Token["GreaterThan_GreaterThan_Equals"] = 97] = "GreaterThan_GreaterThan_Equals";
+    Token[Token["GreaterThan_GreaterThan_GreaterThan_Equals"] = 98] = "GreaterThan_GreaterThan_GreaterThan_Equals";
+    Token[Token["Ampersand_Equals"] = 99] = "Ampersand_Equals";
+    Token[Token["Bar_Equals"] = 100] = "Bar_Equals";
+    Token[Token["Caret_Equals"] = 101] = "Caret_Equals";
+    Token[Token["At"] = 102] = "At";
     /** `??=` */
-    Token[Token["Question_Question_Equals"] = 94] = "Question_Question_Equals";
+    Token[Token["Question_Question_Equals"] = 103] = "Question_Question_Equals";
     /** `||=` */
-    Token[Token["Bar_Bar_Equals"] = 95] = "Bar_Bar_Equals";
+    Token[Token["Bar_Bar_Equals"] = 104] = "Bar_Bar_Equals";
     /** `&&=` */
-    Token[Token["Ampersand_Ampersand_Equals"] = 96] = "Ampersand_Ampersand_Equals";
+    Token[Token["Ampersand_Ampersand_Equals"] = 105] = "Ampersand_Ampersand_Equals";
     /** `??` */
-    Token[Token["Question_Question"] = 97] = "Question_Question";
+    Token[Token["Question_Question"] = 106] = "Question_Question";
     /** `?.` */
-    Token[Token["Question_Dot"] = 98] = "Question_Dot";
+    Token[Token["Question_Dot"] = 107] = "Question_Dot";
     /** `!.` */
-    Token[Token["Exclamation_Dot"] = 99] = "Exclamation_Dot";
+    Token[Token["Exclamation_Dot"] = 108] = "Exclamation_Dot";
     // custom native types for pebble
-    Token[Token["Data"] = 100] = "Data";
-    Token[Token["Bytes"] = 101] = "Bytes";
-    Token[Token["Optional"] = 102] = "Optional";
-    Token[Token["List"] = 103] = "List";
-    Token[Token["LinearMap"] = 104] = "LinearMap";
+    Token[Token["Data"] = 109] = "Data";
+    Token[Token["Bytes"] = 110] = "Bytes";
+    Token[Token["Optional"] = 111] = "Optional";
+    Token[Token["List"] = 112] = "List";
+    Token[Token["LinearMap"] = 113] = "LinearMap";
     // struct decl modifiers
     // taggedModifier,     // `tagged` data struct
-    Token[Token["Runtime"] = 105] = "Runtime";
+    Token[Token["Runtime"] = 114] = "Runtime";
     // literals
-    Token[Token["Identifier"] = 106] = "Identifier";
-    Token[Token["StringLiteral"] = 107] = "StringLiteral";
-    Token[Token["HexBytesLiteral"] = 108] = "HexBytesLiteral";
-    Token[Token["IntegerLiteral"] = 109] = "IntegerLiteral";
+    Token[Token["Identifier"] = 115] = "Identifier";
+    Token[Token["StringLiteral"] = 116] = "StringLiteral";
+    Token[Token["HexBytesLiteral"] = 117] = "HexBytesLiteral";
+    Token[Token["IntegerLiteral"] = 118] = "IntegerLiteral";
     // FloatLiteral,
-    Token[Token["StringTemplateLiteralQuote"] = 110] = "StringTemplateLiteralQuote";
+    Token[Token["StringTemplateLiteralQuote"] = 119] = "StringTemplateLiteralQuote";
     // meta
-    Token[Token["Invalid"] = 111] = "Invalid";
-    Token[Token["EndOfFile"] = 112] = "EndOfFile";
+    Token[Token["Invalid"] = 120] = "Invalid";
+    Token[Token["EndOfFile"] = 121] = "EndOfFile";
 })(Token || (Token = {}));
 Object.freeze(Token);
 /*

package/dist/tokenizer/utils/tokenFromKeyword.js

@@ -31,6 +31,12 @@ export function tokenFromKeyword(text) {
                 return Token.Const;
             if (text === "continue")
                 return Token.Continue;
+            if (text === "contract")
+                return Token.Contract;
+            if (text === "certify")
+                return Token.Certify;
+            if (text === "context")
+                return Token.Context;
             // if (text === "constructor") return Token.Constructor;
             break;
         }
@@ -44,6 +50,8 @@ export function tokenFromKeyword(text) {
             // if (text === "delete") return Token.Delete;
             if (text === "debugger")
                 return Token.Debugger;
+            if (text === "data")
+                return Token.Data;
             break;
         }
         case 101 /* CharCode.e */: {
@@ -129,6 +137,8 @@ export function tokenFromKeyword(text) {
             // if (text === "module") return Token.Module;
             if (text === "match")
                 return Token.Match;
+            if (text === "mint")
+                return Token.Mint;
             break;
         }
         case 110 /* CharCode.n */: {
@@ -145,21 +155,27 @@ export function tokenFromKeyword(text) {
             // if (text === "override") return Token.Override;
             break;
         }
-        // case CharCode.p: {
-        //     if (len === 7) {
-        //         if (text === "private") return Token.Private;
-        //         if (text === "package") return Token.Package;
-        //         break;
-        //     }
-        //     if (text === "public") return Token.Public;
-        //     if (text === "protected") return Token.Protected;
-        //     break;
-        // }
+        case 112 /* CharCode.p */: {
+            // if (len === 7) {
+            //     if (text === "private") return Token.Private;
+            //     if (text === "package") return Token.Package;
+            //     break;
+            // }
+            // if (text === "public") return Token.Public;
+            // if (text === "protected") return Token.Protected;
+            if (text === "param")
+                return Token.Param;
+            if (text === "propose")
+                return Token.Propose;
+            break;
+        }
         case 114 /* CharCode.r */: {
             if (text === "return")
                 return Token.Return;
             if (text === "readonly")
                 return Token.Readonly;
+            if (text === "runtime")
+                return Token.Runtime;
             break;
         }
         case 115 /* CharCode.s */: {
@@ -171,6 +187,8 @@ export function tokenFromKeyword(text) {
                     return Token.Struct;
                 break;
             }
+            if (text === "spend")
+                return Token.Spend;
             // if (text === "set") return Token.Set;
             // if (text === "super") return Token.Super;
             break;
@@ -202,6 +220,8 @@ export function tokenFromKeyword(text) {
                 return Token.Var;
             if (text === "void")
                 return Token.Void;
+            if (text === "vote")
+                return Token.Vote;
             break;
         }
         case 119 /* CharCode.w */: {
@@ -210,6 +230,8 @@ export function tokenFromKeyword(text) {
             if (text === "when")
                 return Token.When;
             // if (text === "with") return Token.With;
+            if (text === "withdraw")
+                return Token.Withdraw;
             break;
         }
         // case CharCode.y: {

package/dist/tokenizer/utils/tokenIsAlsoIdentifier.js

@@ -17,6 +17,16 @@ export function tokenIsAlsoIdentifier(token) {
         // case Token.Namespace:
         // case Token.Null:
         case Token.Readonly:
+        // all the contract keywords are also identifiers (except 'context')
+        case Token.Contract:
+        case Token.Param:
+        case Token.Spend:
+        case Token.Mint:
+        case Token.Certify:
+        case Token.Withdraw:
+        case Token.Propose:
+        case Token.Vote:
+        // case Token.Context:
         // case Token.Type: // we don't allow it in pebble
         case Token.Void: return true;
         default: return false;

package/dist/utils/BitUtils/index.js

@@ -48,7 +48,7 @@ export default class BitUtils {
     static minBytesRequired(bigint) {
         if (bigint < BigInt(0))
             throw new Error("BitUtils.minBytesRequired works for positives integers only");
-        const fullByteOnes = BigInt(255);
+        const fullByteOnes = BigInt(0b1111_1111);
         let mask = fullByteOnes;
         let bytesRequired = 1;
         while (bigint !== (bigint & mask)) {

package/dist/utils/UPLCFlatUtils/index.js

@@ -45,7 +45,7 @@ export default class UPLCFlatUtils {
         assert(integer > BigInt(0), "'UPLCFlatUtils.encodeBigIntAsVariableLengthBitStream' can only encode non-negative integers; the given input was: " + integer.toString());
         // store binary string for easy BitStream creation
         const chunks = [];
-        let mask = BigInt(127);
+        let mask = BigInt(0b0111_1111);
         // 1. Converting to binary
         const nBits = BitUtils.getNOfUsedBits(integer);
         for (let nAddedBits = 0; nAddedBits < nBits; nAddedBits += 7) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.0-dev4",
+  "version": "0.1.0-dev6",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,6 +17,7 @@
     "buidl": "npm run build",
     "build": "rm -rf ./dist && npm run build:light",
     "build:light": "npm run genDiagnosticMessages && tsc --project ./tsconfig.json && tsc-alias -p ./tsconfig.json",
+    "build-and-replace": "npm run build && cp -r ./dist ../pebble-cli/node_modules/@harmoniclabs/pebble",
     "genDiagnosticMessages": "node ./scripts/genDiagnosticMessages.js",
     "test": "jest",
     "test:debug": "node --nolazy --inspect-brk ./node_modules/jest/bin/jest.js --runInBand --colors --verbose",

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

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

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

@@ -1,22 +0,0 @@
-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/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/subRoutines/handleLetted/incrementUnboundDbns.d.ts

@@ -1,9 +0,0 @@
-import { IRTerm } from "../../../IRTerm.js";
-import { IRLetted } from "../../../IRNodes/IRLetted.js";
-/**
- *  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
-**/
-export declare function incrementUnboundDbns(theTerm: IRTerm, shouldNotModifyLetted: (letted: IRLetted, dbn: number) => boolean): void;

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

@@ -1,73 +0,0 @@
-import { IRVar } from "../../../IRNodes/IRVar.js";
-import { IRLetted } from "../../../IRNodes/IRLetted.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 { IRCase } from "../../../IRNodes/IRCase.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
-import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
-import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
-/**
- *  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
-**/
-export function incrementUnboundDbns(theTerm, shouldNotModifyLetted) {
-    const stack = [{ term: theTerm, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term: t, dbn } = stack.pop();
-        if ((t instanceof IRVar ||
-            t instanceof IRSelfCall) &&
-            t.dbn >= dbn) {
-            // there's a new variable in scope
-            t.dbn++;
-            continue;
-        }
-        if (t instanceof IRLetted) {
-            if (shouldNotModifyLetted(t, dbn)) {
-                // don't modify letted to be hoisted
-                continue;
-            }
-            else // other letted to be handled in one of the next cycles
-             {
-                // `IRLambdas` DeBruijn are tracking the level of instantiation
-                // we add a new variable so the dbn of instantiation increments
-                t.dbn += 1;
-                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;
-        }
-        // skip hoisted since closed
-    }
-}

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

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