@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

package/dist/IR/IRNodes/IRConst.js

@@ -1,273 +0,0 @@
-import { Pair } from "@harmoniclabs/pair";
-import { isData, dataToCbor } from "@harmoniclabs/plutus-data";
-import { fromUtf8, toHex } from "@harmoniclabs/uint8array-utils";
-import { BasePlutsError } from "../../utils/BasePlutsError.js";
-import UPLCFlatUtils from "../../utils/UPLCFlatUtils/index.js";
-import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { positiveBigIntAsBytes } from "../utils/positiveIntAsBytes.js";
-import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-import { getUnaliased } from "../../compiler/tir/types/utils/getUnaliased.js";
-import { TirAliasType } from "../../compiler/tir/types/TirAliasType.js";
-import { TirDataStructType, TirSoPStructType } from "../../compiler/tir/types/TirStructType.js";
-import { getListTypeArg } from "../../compiler/tir/types/utils/getListTypeArg.js";
-import { TirTypeParam } from "../../compiler/tir/types/TirTypeParam.js";
-import { constT, UPLCConst } from "@harmoniclabs/uplc";
-import { TirPairDataT, TirUnConstrDataResultT } from "../../compiler/tir/types/TirNativeType/index.js";
-import { TirBoolT } from "../../compiler/tir/types/TirNativeType/native/bool.js";
-import { TirBytesT } from "../../compiler/tir/types/TirNativeType/native/bytes.js";
-import { TirDataT } from "../../compiler/tir/types/TirNativeType/native/data.js";
-import { TirFuncT } from "../../compiler/tir/types/TirNativeType/native/function.js";
-import { TirIntT } from "../../compiler/tir/types/TirNativeType/native/int.js";
-import { TirLinearMapT } from "../../compiler/tir/types/TirNativeType/native/linearMap.js";
-import { TirListT } from "../../compiler/tir/types/TirNativeType/native/list.js";
-import { TirDataOptT } from "../../compiler/tir/types/TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../../compiler/tir/types/TirNativeType/native/Optional/sop.js";
-import { TirStringT } from "../../compiler/tir/types/TirNativeType/native/string.js";
-import { TirVoidT } from "../../compiler/tir/types/TirNativeType/native/void.js";
-export function isIRConstPair(value) {
-    return (value instanceof Pair &&
-        isIRConstValue(value.fst) &&
-        isIRConstValue(value.snd));
-}
-export class IRConst {
-    type;
-    value;
-    static get kind() { return IRNodeKind.Const; }
-    get kind() { return IRConst.kind; }
-    static get tag() { return new Uint8Array([IRConst.kind]); }
-    constructor(type, value, _unsafeHash) {
-        this.type = type;
-        this.value = value;
-        if (!(isValueAssignableToType(value, type)))
-            throw new BasePlutsError("invalid IR constant value for type " + type.toString());
-        this._parent = undefined;
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-    }
-    toUPLC() {
-        return new UPLCConst(tirTypeToUplcType(getUnaliased(this.type)), this.value);
-    }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRConst.tag, new Uint8Array(this.type.toUplcConstType()), serializeIRConstValue(this.value, this.type)));
-        }
-        return this._hash;
-    }
-    markHashAsInvalid() { {
-        throw new Error("IRConst `markHashAsInvalid` was called; but a constant doesn't have childs");
-    } }
-    isHashPresent() { return isIRHash(this._hash); }
-    _meta = undefined;
-    get meta() {
-        if (!this._meta)
-            this._meta = {};
-        return this._meta;
-    }
-    _parent;
-    get parent() { return this._parent; }
-    set parent(newParent) {
-        if (!( // assert
-        // new parent value is different than current
-        this._parent !== newParent && (
-        // and the new parent value is valid
-        newParent === undefined ||
-            isIRParentTerm(newParent))))
-            return;
-        this._parent = newParent;
-    }
-    clone() {
-        return new IRConst(this.type, this.value, this.isHashPresent() ? this.hash : undefined);
-    }
-    toJSON() { return this.toJson(); }
-    toJson() {
-        return {
-            type: "IRConst",
-            constType: this.type.toString(),
-            value: constValueToJson(this.value)
-        };
-    }
-    static get unit() {
-        return new IRConst(new TirVoidT(), undefined);
-    }
-    static bool(b) {
-        return new IRConst(new TirBoolT(), b);
-    }
-    static bytes(b) {
-        return new IRConst(new TirBytesT(), b);
-    }
-    static int(n) {
-        return new IRConst(new TirIntT(), BigInt(n));
-    }
-    static str(string) {
-        return new IRConst(new TirStringT(), string);
-    }
-    static data(d) {
-        return new IRConst(new TirDataT(), d);
-    }
-    static listOf(t) {
-        return (vals) => new IRConst(new TirListT(t), vals);
-    }
-}
-function isIRConstValueList(value) {
-    if (!Array.isArray(value))
-        return false;
-    if (value.length === 0)
-        return true;
-    return value.every(isIRConstValue);
-}
-function isValueAssignableToType(value, type) {
-    type = getUnaliased(type);
-    if (
-    // so that typescirpt is happy
-    type instanceof TirAliasType
-        || type instanceof TirFuncT
-        || type instanceof TirSopOptT
-        || type instanceof TirSoPStructType
-        || type instanceof TirTypeParam)
-        return false;
-    if (type instanceof TirVoidT)
-        return value === undefined;
-    if (type instanceof TirBoolT)
-        return typeof value === "boolean";
-    if (type instanceof TirIntT)
-        return typeof value === "bigint";
-    if (type instanceof TirBytesT)
-        return value instanceof Uint8Array;
-    if (type instanceof TirStringT)
-        return typeof value === "string";
-    if (type instanceof TirPairDataT)
-        return (isIRConstPair(value)
-            && isValueAssignableToType(value.fst, new TirDataT())
-            && isValueAssignableToType(value.snd, new TirDataT()));
-    if (type instanceof TirLinearMapT) {
-        return (Array.isArray(value)
-            && value.every(v => isValueAssignableToType(v, new TirPairDataT)));
-    }
-    if (type instanceof TirUnConstrDataResultT)
-        return (isIRConstPair(value)
-            && isValueAssignableToType(value.fst, new TirIntT())
-            && isValueAssignableToType(value.snd, new TirListT(new TirDataT())));
-    if (type instanceof TirDataT
-        || type instanceof TirDataOptT
-        || type instanceof TirDataStructType)
-        return isData(value);
-    if (type instanceof TirListT) {
-        const elemsT = getListTypeArg(type);
-        return (Array.isArray(value) &&
-            value.every(v => isValueAssignableToType(v, elemsT)));
-    }
-    const tsEnsureExsaustiveCheck = type;
-    return false;
-}
-export function isIRConstValue(value) {
-    return (typeof value === "bigint"
-        || value instanceof Uint8Array
-        || typeof value === "string"
-        || typeof value === "boolean"
-        || isIRConstValueList(value)
-        || isIRConstPair(value)
-        || isData(value)
-        || typeof value === "undefined");
-}
-function serializeIRConstValue(value, type) {
-    type = getUnaliased(type);
-    if (type instanceof TirAliasType)
-        throw new Error("unreachable");
-    if (type instanceof TirVoidT)
-        return new Uint8Array(0);
-    if (type instanceof TirIntT) {
-        return positiveBigIntAsBytes(UPLCFlatUtils.zigzagBigint(BigInt(value)));
-    }
-    if (type instanceof TirStringT)
-        return fromUtf8(value);
-    if (type instanceof TirBytesT) {
-        if (value instanceof Uint8Array)
-            return value.slice();
-        throw new Error("invalid value");
-    }
-    if (type instanceof TirBoolT)
-        return new Uint8Array([value ? 1 : 0]);
-    if (type instanceof TirListT) {
-        const elemsT = getListTypeArg(type);
-        return concatUint8Arr(...value.map(stuff => serializeIRConstValue(stuff, elemsT)));
-    }
-    if (type instanceof TirLinearMapT) {
-        return concatUint8Arr(...value.map(stuff => serializeIRConstValue(stuff, new TirPairDataT())));
-    }
-    if (type instanceof TirPairDataT) {
-        return concatUint8Arr(serializeIRConstValue(value.fst, new TirDataT()), serializeIRConstValue(value.snd, new TirDataT()));
-    }
-    if (type instanceof TirUnConstrDataResultT) {
-        return concatUint8Arr(serializeIRConstValue(BigInt(value.fst), new TirIntT()), serializeIRConstValue(value.snd, new TirListT(new TirDataT())));
-    }
-    if (type instanceof TirDataT
-        || type instanceof TirDataOptT
-        || type instanceof TirDataStructType)
-        return dataToCbor(value).toBuffer();
-    if (type instanceof TirFuncT
-        || type instanceof TirSopOptT
-        || type instanceof TirSoPStructType
-        || type instanceof TirTypeParam)
-        throw new Error("invalid uplc const type");
-    const tsEnsureExsaustiveCheck = type;
-    throw new Error("unreachable");
-}
-export function constValueToJson(value) {
-    if (typeof value === "bigint")
-        return value.toString();
-    if (value instanceof Uint8Array)
-        return toHex(value);
-    if (typeof value === "string")
-        return value;
-    if (typeof value === "boolean")
-        return value;
-    if (isIRConstValueList(value))
-        return value.map(constValueToJson);
-    if (isIRConstPair(value))
-        return {
-            fst: constValueToJson(value.fst),
-            snd: constValueToJson(value.snd)
-        };
-    if (isData(value))
-        return dataToCbor(value).toString();
-    if (typeof value === "undefined")
-        return null;
-    throw new Error("unreachable");
-}
-export function tirTypeToUplcType(t) {
-    t = getUnaliased(t);
-    if (t instanceof TirVoidT)
-        return constT.unit;
-    if (t instanceof TirBoolT)
-        return constT.bool;
-    if (t instanceof TirIntT)
-        return constT.int;
-    if (t instanceof TirBytesT)
-        return constT.byteStr;
-    if (t instanceof TirStringT)
-        return constT.str;
-    if (t instanceof TirListT) {
-        const elemsT = tirTypeToUplcType(getListTypeArg(t));
-        return constT.listOf(elemsT);
-    }
-    if (t instanceof TirDataT
-        || t instanceof TirDataOptT
-        || t instanceof TirDataStructType)
-        return constT.data;
-    if (t instanceof TirPairDataT)
-        return constT.pairOf(constT.data, constT.data);
-    if (t instanceof TirLinearMapT)
-        return constT.listOf(constT.pairOf(constT.data, constT.data));
-    if (t instanceof TirUnConstrDataResultT)
-        return constT.pairOf(constT.int, constT.listOf(constT.data));
-    if (t instanceof TirAliasType
-        || t instanceof TirFuncT
-        || t instanceof TirSopOptT
-        || t instanceof TirSoPStructType
-        || t instanceof TirTypeParam)
-        throw new Error("invalid uplc const type");
-    const tsEnsureExsaustiveCheck = t;
-    throw new Error("tirTypeToUplcType: unreachable");
-}

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

@@ -1,30 +0,0 @@
-import { Cloneable } from "../../utils/Cloneable.js";
-import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash, IIRParent } from "../interfaces/index.js";
-import { IRParentTerm } from "../utils/isIRParentTerm.js";
-import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { MutArrayLike } from "../utils/MutArrayLike.js";
-import { IRHash } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export interface IRConstrMeta extends BaseIRMetadata {
-}
-export declare class IRConstr implements Cloneable<IRConstr>, IHash, IIRParent, ToJson {
-    readonly index: bigint;
-    readonly fields: MutArrayLike<IRTerm>;
-    readonly meta: IRConstrMeta;
-    static get kind(): IRNodeKind.Constr;
-    get kind(): IRNodeKind.Constr;
-    static get tag(): Uint8Array;
-    constructor(index: number | bigint, fields: ArrayLike<IRTerm>, meta?: IRConstrMeta, _unsafeHash?: IRHash);
-    private _hash;
-    get hash(): IRHash;
-    markHashAsInvalid(): void;
-    isHashPresent(): boolean;
-    private _parent;
-    get parent(): IRParentTerm | undefined;
-    set parent(newParent: IRParentTerm | undefined);
-    clone(): IRConstr;
-    toJSON(): any;
-    toJson(): any;
-}

package/dist/IR/IRNodes/IRConstr.js

@@ -1,87 +0,0 @@
-import { forceBigUInt } from "../../utils/ints.js";
-import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
-import { mapArrayLike } from "./utils/mapArrayLike.js";
-import { makeArrayLikeProxy } from "./utils/makeArrayLikeProxy.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-import { isIRTerm } from "../utils/isIRTerm.js";
-export class IRConstr {
-    index;
-    fields;
-    meta;
-    static get kind() { return IRNodeKind.Constr; }
-    get kind() { return IRConstr.kind; }
-    static get tag() { return new Uint8Array([IRNodeKind.Constr]); }
-    constructor(index, fields, meta = {}, _unsafeHash) {
-        const self = this;
-        this.meta = meta;
-        this._parent = undefined;
-        Object.defineProperty(this, "index", {
-            value: forceBigUInt(index),
-            writable: false,
-            enumerable: true,
-            configurable: false
-        });
-        Object.defineProperty(this, "fields", {
-            value: makeArrayLikeProxy(fields, isIRTerm, 
-            // initModifyElem
-            newElem => {
-                // newElem = newElem.clone();
-                newElem.parent = self;
-                // self.markHashAsInvalid()
-                return newElem;
-            }, 
-            // modifyElem
-            // called before setting the new value
-            // the return value is the value that will be set
-            (newElem, oldElem) => {
-                if (!shallowEqualIRTermHash(oldElem, newElem))
-                    self.markHashAsInvalid();
-                newElem.parent = self;
-                return newElem;
-            }),
-            writable: false,
-            enumerable: true,
-            configurable: false
-        });
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-    }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            // basically a merkle tree
-            this._hash = hashIrData(concatUint8Arr(IRConstr.tag, positiveIntAsBytes(this.index), ...mapArrayLike(this.fields, f => f.hash)));
-        }
-        return this._hash;
-    }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this.parent?.markHashAsInvalid();
-    }
-    isHashPresent() { return isIRHash(this._hash); }
-    _parent;
-    get parent() { return this._parent; }
-    set parent(newParent) {
-        if (!( // assert
-        // new parent value is different than current
-        this._parent !== newParent && (
-        // and the new parent value is valid
-        newParent === undefined ||
-            isIRParentTerm(newParent))))
-            return;
-        this._parent = newParent;
-    }
-    clone() {
-        return new IRConstr(this.index, mapArrayLike(this.fields, f => f.clone()), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
-    }
-    toJSON() { return this.toJson(); }
-    toJson() {
-        return {
-            index: this.index.toString(),
-            fields: mapArrayLike(this.fields, f => f.toJson())
-        };
-    }
-}

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

@@ -1,31 +0,0 @@
-import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
-import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash } from "../interfaces/IHash.js";
-import { IIRParent } from "../interfaces/IIRParent.js";
-import { IRParentTerm } from "../utils/isIRParentTerm.js";
-import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export interface IRDelayedMetadata extends BaseIRMetadata {
-}
-export declare class IRDelayed implements Cloneable<IRDelayed>, IHash, IIRParent, ToJson {
-    readonly meta: IRDelayedMetadata;
-    constructor(delayed: IRTerm, _unsafeHash?: IRHash);
-    static get kind(): IRNodeKind.Delayed;
-    get kind(): IRNodeKind.Delayed;
-    static get tag(): Uint8Array;
-    private _delayed;
-    get delayed(): IRTerm;
-    set delayed(newDelayed: IRTerm | undefined);
-    private _hash;
-    get hash(): IRHash;
-    private _parent;
-    get parent(): IRParentTerm | undefined;
-    set parent(newParent: IRParentTerm | undefined);
-    isHashPresent(): boolean;
-    markHashAsInvalid(): void;
-    clone(): IRDelayed;
-    toJSON(): any;
-    toJson(): any;
-}

package/dist/IR/IRNodes/IRDelayed.js

@@ -1,68 +0,0 @@
-import { BasePlutsError } from "../../utils/BasePlutsError.js";
-import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { isIRTerm } from "../utils/isIRTerm.js";
-import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export class IRDelayed {
-    meta = {};
-    constructor(delayed, _unsafeHash) {
-        if (!isIRTerm(delayed))
-            throw new Error("IRDelayed argument was not an IRTerm");
-        this._delayed = delayed;
-        this._delayed.parent = this;
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-        this._parent = undefined;
-    }
-    static get kind() { return IRNodeKind.Delayed; }
-    get kind() { return IRDelayed.kind; }
-    static get tag() { return new Uint8Array([IRDelayed.kind]); }
-    _delayed;
-    get delayed() { return this._delayed; }
-    set delayed(newDelayed) {
-        if (!isIRTerm(newDelayed)) {
-            throw new BasePlutsError("invalid IRTerm to be delayed");
-        }
-        if (!shallowEqualIRTermHash(this._delayed, newDelayed))
-            this.markHashAsInvalid();
-        // keep the parent reference in the old child, useful for compilation
-        // _delayed.parent = undefined;
-        this._delayed = newDelayed;
-        this._delayed.parent = this;
-    }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRDelayed.tag, this.delayed.hash));
-        }
-        return this._hash;
-    }
-    _parent;
-    get parent() { return this._parent; }
-    set parent(newParent) {
-        if (!( // assert
-        // new parent value is different than current
-        this._parent !== newParent && (
-        // and the new parent value is valid
-        newParent === undefined ||
-            isIRParentTerm(newParent))))
-            return;
-        this._parent = newParent;
-    }
-    isHashPresent() { return isIRHash(this._hash); }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this._parent?.markHashAsInvalid();
-    }
-    clone() {
-        return new IRDelayed(this.delayed.clone(), this.isHashPresent() ? this.hash : undefined);
-    }
-    toJSON() { return this.toJson(); }
-    toJson() {
-        return {
-            type: "IRDelayed",
-            delayed: this.delayed.toJson()
-        };
-    }
-}

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

@@ -1,32 +0,0 @@
-import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
-import { ToJson } from "../../utils/ToJson.js";
-import { IHash } from "../interfaces/IHash.js";
-import { IIRParent } from "../interfaces/IIRParent.js";
-import { IRParentTerm } from "../utils/isIRParentTerm.js";
-import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export interface IRErrorMetadata extends BaseIRMetadata {
-}
-export declare class IRError implements Cloneable<IRError>, IHash, IIRParent, ToJson {
-    readonly meta: IRErrorMetadata;
-    msg?: string;
-    addInfos?: any;
-    constructor(msg?: string, addInfos?: any);
-    static get kind(): IRNodeKind.Error;
-    get kind(): IRNodeKind.Error;
-    static get tag(): Uint8Array;
-    get hash(): IRHash;
-    isHashPresent(): boolean;
-    markHashAsInvalid(): void;
-    private _parent;
-    get parent(): IRParentTerm | undefined;
-    set parent(newParent: IRParentTerm | undefined);
-    clone(): IRError;
-    toJSON(): {
-        type: string;
-    };
-    toJson(): {
-        type: string;
-    };
-}

package/dist/IR/IRNodes/IRError.js

@@ -1,44 +0,0 @@
-import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-const irErrorBitTag = new Uint8Array([IRNodeKind.Error]);
-const errorHash = hashIrData(irErrorBitTag.slice());
-export class IRError {
-    meta;
-    msg;
-    addInfos;
-    constructor(msg, addInfos) {
-        this.msg = msg;
-        this.addInfos = addInfos ?? {};
-        this.meta = {};
-        this._parent = undefined;
-    }
-    static get kind() { return IRNodeKind.Error; }
-    get kind() { return IRError.kind; }
-    static get tag() { return irErrorBitTag.slice(); }
-    get hash() { return errorHash; }
-    isHashPresent() { return true; }
-    markHashAsInvalid() { throw new Error("IRError.markHashAsInvalid was called but error doesn't have childs"); }
-    _parent;
-    get parent() { return this._parent; }
-    set parent(newParent) {
-        if (!( // assert
-        // new parent value is different than current
-        this._parent !== newParent && (
-        // and the new parent value is valid
-        newParent === undefined ||
-            isIRParentTerm(newParent))))
-            return;
-        this._parent = newParent;
-    }
-    clone() {
-        return new IRError(this.msg, { ...this.addInfos });
-    }
-    toJSON() { return this.toJson(); }
-    toJson() {
-        return {
-            type: "IRError"
-        };
-    }
-}
-;

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

@@ -1,31 +0,0 @@
-import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
-import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash } from "../interfaces/IHash.js";
-import { IIRParent } from "../interfaces/IIRParent.js";
-import { IRParentTerm } from "../utils/isIRParentTerm.js";
-import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export interface IRForcedMetadata extends BaseIRMetadata {
-}
-export declare class IRForced implements Cloneable<IRForced>, IHash, IIRParent, ToJson {
-    readonly meta: IRForcedMetadata;
-    constructor(forced: IRTerm, _unsafeHash?: IRHash);
-    private _forced;
-    get forced(): IRTerm;
-    set forced(newForced: IRTerm | undefined);
-    private _hash;
-    get hash(): IRHash;
-    isHashPresent(): boolean;
-    markHashAsInvalid(): void;
-    private _parent;
-    get parent(): IRParentTerm | undefined;
-    set parent(newParent: IRParentTerm | undefined);
-    static get kind(): IRNodeKind.Forced;
-    get kind(): IRNodeKind.Forced;
-    static get tag(): Uint8Array;
-    clone(): IRForced;
-    toJSON(): any;
-    toJson(): any;
-}

package/dist/IR/IRNodes/IRForced.js

@@ -1,69 +0,0 @@
-import { BasePlutsError } from "../../utils/BasePlutsError.js";
-import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { isIRTerm } from "../utils/isIRTerm.js";
-import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export class IRForced {
-    meta;
-    constructor(forced, _unsafeHash) {
-        this.meta = {};
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-        if (!isIRTerm(forced))
-            throw new Error("IRForced argument was not an IRTerm");
-        this._forced = forced;
-        this._forced.parent = this;
-        this._parent = undefined;
-    }
-    _forced;
-    get forced() { return this._forced; }
-    set forced(newForced) {
-        if (!isIRTerm(newForced)) {
-            throw new BasePlutsError("invalid IRTerm to be forced");
-        }
-        if (!shallowEqualIRTermHash(this._forced, newForced))
-            this.markHashAsInvalid();
-        // keep the parent reference in the old child, useful for compilation
-        // _forced.parent = undefined;
-        this._forced = newForced;
-        this._forced.parent = this;
-    }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRForced.tag, this._forced.hash));
-        }
-        return this._hash;
-    }
-    isHashPresent() { return isIRHash(this._hash); }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this.parent?.markHashAsInvalid();
-    }
-    _parent;
-    get parent() { return this._parent; }
-    set parent(newParent) {
-        if (!( // assert
-        // new parent value is different than current
-        this._parent !== newParent && (
-        // and the new parent value is valid
-        newParent === undefined ||
-            isIRParentTerm(newParent))))
-            return;
-        this._parent = newParent;
-    }
-    static get kind() { return IRNodeKind.Forced; }
-    get kind() { return IRForced.kind; }
-    static get tag() { return new Uint8Array([IRForced.kind]); }
-    clone() {
-        return new IRForced(this.forced.clone(), this.isHashPresent() ? this.hash : undefined);
-    }
-    toJSON() { return this.toJson(); }
-    toJson() {
-        return {
-            type: "IRForced",
-            forced: this.forced.toJson()
-        };
-    }
-}