@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

package/dist/compiler/tir/types/TirNativeType/native/Optional/sop.js

@@ -1,48 +0,0 @@
-import { getAppliedTirTypeName } from "../../../../program/TypedProgram.js";
-import { TirSoPStructType, TirStructConstr, TirStructField } from "../../../TirStructType.js";
-export class TirSopOptT extends TirSoPStructType {
-    typeArg;
-    constructor(typeArg) {
-        super("Optional", // name
-        "", // fileUid
-        [
-            new TirStructConstr("Some", // name
-            [
-                new TirStructField("value", typeArg)
-            ]),
-            new TirStructConstr("None", []) // name, fields
-        ], new Map() // methodNamesPtr
-        );
-        this.typeArg = typeArg;
-    }
-    hasDataEncoding() { return false; }
-    toAstName() {
-        return "Optional";
-    }
-    toString() {
-        return `${this.toAstName()}<${this.typeArg.toString()}>`;
-    }
-    static toTirTypeKey() {
-        return "sop_opt";
-    }
-    toTirTypeKey() {
-        return TirSopOptT.toTirTypeKey();
-    }
-    toConcreteTirTypeName() {
-        return getAppliedTirTypeName(this.toTirTypeKey(), [this.typeArg.toConcreteTirTypeName()]);
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = this.typeArg.isConcrete();
-        return this._isConcrete;
-    }
-    clone() {
-        const result = new TirSopOptT(this.typeArg.clone());
-        result._isConcrete = this._isConcrete;
-        return result;
-    }
-    toUplcConstType() {
-        throw new Error("SoP encoded optional cannot be represented as uplc const");
-    }
-}

package/dist/compiler/tir/types/TirNativeType/native/bool.d.ts

@@ -1,13 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import type { ITirType } from "../../TirType.js";
-export declare class TirBoolT implements ITirType {
-    clone(): TirBoolT;
-    isConcrete(): boolean;
-    toString(): string;
-    toAstName(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    hasDataEncoding(): boolean;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/bool.js

@@ -1,12 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-export class TirBoolT {
-    clone() { return new TirBoolT(); }
-    isConcrete() { return true; }
-    toString() { return "boolean"; }
-    toAstName() { return "boolean"; }
-    static toTirTypeKey() { return "boolean"; }
-    toTirTypeKey() { return TirBoolT.toTirTypeKey(); }
-    toConcreteTirTypeName() { return this.toTirTypeKey(); }
-    hasDataEncoding() { return true; }
-    toUplcConstType() { return constT.bool; }
-}

package/dist/compiler/tir/types/TirNativeType/native/bytes.d.ts

@@ -1,13 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { ITirType } from "../../TirType.js";
-export declare class TirBytesT implements ITirType {
-    clone(): TirBytesT;
-    isConcrete(): boolean;
-    toString(): string;
-    toAstName(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    hasDataEncoding(): boolean;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/bytes.js

@@ -1,12 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-export class TirBytesT {
-    clone() { return new TirBytesT(); }
-    isConcrete() { return true; }
-    toString() { return "bytes"; }
-    toAstName() { return "bytes"; }
-    static toTirTypeKey() { return "bytes"; }
-    toTirTypeKey() { return TirBytesT.toTirTypeKey(); }
-    toConcreteTirTypeName() { return this.toTirTypeKey(); }
-    hasDataEncoding() { return true; }
-    toUplcConstType() { return constT.byteStr; }
-}

package/dist/compiler/tir/types/TirNativeType/native/data.d.ts

@@ -1,13 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { ITirType } from "../../TirType.js";
-export declare class TirDataT implements ITirType {
-    clone(): TirDataT;
-    isConcrete(): boolean;
-    toString(): string;
-    toAstName(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    hasDataEncoding(): boolean;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/data.js

@@ -1,12 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-export class TirDataT {
-    clone() { return new TirDataT(); }
-    isConcrete() { return true; }
-    toString() { return "data"; }
-    toAstName() { return "data"; }
-    static toTirTypeKey() { return "data"; }
-    toTirTypeKey() { return TirDataT.toTirTypeKey(); }
-    toConcreteTirTypeName() { return this.toTirTypeKey(); }
-    hasDataEncoding() { return true; }
-    toUplcConstType() { return constT.data; }
-}

package/dist/compiler/tir/types/TirNativeType/native/function.d.ts

@@ -1,16 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { ITirType, TirType } from "../../TirType.js";
-export declare class TirFuncT implements ITirType {
-    readonly argTypes: TirType[];
-    readonly returnType: TirType;
-    constructor(argTypes: TirType[], returnType: TirType);
-    hasDataEncoding(): boolean;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    toAstName(): string;
-    toString(): string;
-    private _isConcrete;
-    isConcrete(): boolean;
-    clone(): TirFuncT;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/function.js

@@ -1,38 +0,0 @@
-export class TirFuncT {
-    argTypes;
-    returnType;
-    constructor(
-    // readonly genericTyArgsName: TirTypeParam[],
-    argTypes, returnType) {
-        this.argTypes = argTypes;
-        this.returnType = returnType;
-    }
-    hasDataEncoding() { return false; }
-    toTirTypeKey() {
-        return "func_" + this.argTypes.map(t => t.toConcreteTirTypeName()).join("_") + "_" + this.returnType.toConcreteTirTypeName();
-    }
-    toConcreteTirTypeName() {
-        return this.toTirTypeKey();
-    }
-    toAstName() {
-        return this.toTirTypeKey();
-    }
-    toString() {
-        return `(${this.argTypes.map(t => t.toString()).join(",")}) => ${this.returnType.toString()}`;
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = (this.argTypes.every(t => t.isConcrete())
-                && this.returnType.isConcrete());
-        return this._isConcrete ?? false;
-    }
-    clone() {
-        const result = new TirFuncT(this.argTypes.map(t => t.clone()), this.returnType.clone());
-        result._isConcrete = this._isConcrete;
-        return result;
-    }
-    toUplcConstType() {
-        throw new Error("TirFuncT cannot be represented as uplc const type");
-    }
-}

package/dist/compiler/tir/types/TirNativeType/native/index.d.ts

@@ -1,10 +0,0 @@
-export * from "./Optional/index.js";
-export * from "./bool.js";
-export * from "./bytes.js";
-export * from "./data.js";
-export * from "./function.js";
-export * from "./int.js";
-export * from "./linearMap.js";
-export * from "./list.js";
-export * from "./string.js";
-export * from "./void.js";

package/dist/compiler/tir/types/TirNativeType/native/index.js

@@ -1,10 +0,0 @@
-export * from "./Optional/index.js";
-export * from "./bool.js";
-export * from "./bytes.js";
-export * from "./data.js";
-export * from "./function.js";
-export * from "./int.js";
-export * from "./linearMap.js";
-export * from "./list.js";
-export * from "./string.js";
-export * from "./void.js";

package/dist/compiler/tir/types/TirNativeType/native/int.d.ts

@@ -1,13 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { ITirType } from "../../TirType.js";
-export declare class TirIntT implements ITirType {
-    clone(): TirIntT;
-    isConcrete(): boolean;
-    toString(): string;
-    toAstName(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    hasDataEncoding(): boolean;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/int.js

@@ -1,12 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-export class TirIntT {
-    clone() { return new TirIntT(); }
-    isConcrete() { return true; }
-    toString() { return "int"; }
-    toAstName() { return "int"; }
-    static toTirTypeKey() { return "int"; }
-    toTirTypeKey() { return TirIntT.toTirTypeKey(); }
-    toConcreteTirTypeName() { return this.toTirTypeKey(); }
-    hasDataEncoding() { return true; }
-    toUplcConstType() { return constT.int; }
-}

package/dist/compiler/tir/types/TirNativeType/native/linearMap.d.ts

@@ -1,17 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { TirType, ITirType } from "../../TirType.js";
-export declare class TirLinearMapT<K extends TirType = TirType, V extends TirType = TirType> implements ITirType {
-    readonly keyTypeArg: K;
-    readonly valTypeArg: V;
-    constructor(keyTypeArg: K, valTypeArg: V);
-    hasDataEncoding(): boolean;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toAstName(): string;
-    toConcreteTirTypeName(): string;
-    toString(): string;
-    private _isConcrete;
-    isConcrete(): boolean;
-    clone(): TirLinearMapT<K, V>;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/linearMap.js

@@ -1,44 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-import { getAppliedTirTypeName } from "../../../program/TypedProgram.js";
-export class TirLinearMapT {
-    keyTypeArg;
-    valTypeArg;
-    constructor(keyTypeArg, valTypeArg) {
-        this.keyTypeArg = keyTypeArg;
-        this.valTypeArg = valTypeArg;
-    }
-    hasDataEncoding() { return this.keyTypeArg.hasDataEncoding() && this.valTypeArg.hasDataEncoding(); }
-    static toTirTypeKey() {
-        return "list_pair_data";
-    }
-    toTirTypeKey() {
-        return TirLinearMapT.toTirTypeKey();
-    }
-    toAstName() {
-        return this.toTirTypeKey();
-    }
-    toConcreteTirTypeName() {
-        return getAppliedTirTypeName(this.toTirTypeKey(), [
-            this.keyTypeArg.toConcreteTirTypeName(),
-            this.valTypeArg.toConcreteTirTypeName()
-        ]);
-    }
-    toString() {
-        return `${this.toTirTypeKey()}<${this.keyTypeArg.toString()},${this.valTypeArg.toString()}>`;
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = (this.keyTypeArg.isConcrete()
-                && this.valTypeArg.isConcrete());
-        return this._isConcrete ?? false;
-    }
-    clone() {
-        const result = new TirLinearMapT(this.keyTypeArg.clone(), this.valTypeArg.clone());
-        result._isConcrete = this._isConcrete;
-        return result;
-    }
-    toUplcConstType() {
-        return constT.listOf(constT.pairOf(constT.data, constT.data));
-    }
-}

package/dist/compiler/tir/types/TirNativeType/native/list.d.ts

@@ -1,16 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { TirType, ITirType } from "../../TirType.js";
-export declare class TirListT<T extends TirType = TirType> implements ITirType {
-    readonly typeArg: T;
-    constructor(typeArg: T);
-    hasDataEncoding(): boolean;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    toString(): string;
-    toAstName(): string;
-    private _isConcrete;
-    isConcrete(): boolean;
-    clone(): TirListT<T>;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/list.js

@@ -1,38 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-import { getAppliedTirTypeName } from "../../../program/TypedProgram.js";
-export class TirListT {
-    typeArg;
-    constructor(typeArg) {
-        this.typeArg = typeArg;
-    }
-    hasDataEncoding() { return this.typeArg.hasDataEncoding(); }
-    static toTirTypeKey() {
-        return "List";
-    }
-    toTirTypeKey() {
-        return TirListT.toTirTypeKey();
-    }
-    toConcreteTirTypeName() {
-        return getAppliedTirTypeName(this.toTirTypeKey(), [this.typeArg.toConcreteTirTypeName()]);
-    }
-    toString() {
-        return `${this.toTirTypeKey()}<${this.typeArg.toString()}>`;
-    }
-    toAstName() {
-        return this.toTirTypeKey();
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = this.typeArg.isConcrete();
-        return this._isConcrete ?? false;
-    }
-    clone() {
-        const result = new TirListT(this.typeArg.clone());
-        result._isConcrete = this._isConcrete;
-        return result;
-    }
-    toUplcConstType() {
-        return constT.listOf(this.typeArg.toUplcConstType());
-    }
-}

package/dist/compiler/tir/types/TirNativeType/native/string.d.ts

@@ -1,13 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { ITirType } from "../../TirType.js";
-export declare class TirStringT implements ITirType {
-    clone(): TirStringT;
-    isConcrete(): boolean;
-    toString(): string;
-    toAstName(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    hasDataEncoding(): boolean;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/string.js

@@ -1,12 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-export class TirStringT {
-    clone() { return new TirStringT(); }
-    isConcrete() { return true; }
-    toString() { return "string"; }
-    toAstName() { return "string"; }
-    static toTirTypeKey() { return "string"; }
-    toTirTypeKey() { return TirStringT.toTirTypeKey(); }
-    toConcreteTirTypeName() { return this.toTirTypeKey(); }
-    hasDataEncoding() { return true; }
-    toUplcConstType() { return constT.str; }
-}

package/dist/compiler/tir/types/TirNativeType/native/void.d.ts

@@ -1,13 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { ITirType } from "../../TirType.js";
-export declare class TirVoidT implements ITirType {
-    clone(): TirVoidT;
-    isConcrete(): boolean;
-    toString(): string;
-    toAstName(): string;
-    static toTirTypeKey(): string;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    hasDataEncoding(): boolean;
-    toUplcConstType(): ConstType;
-}

package/dist/compiler/tir/types/TirNativeType/native/void.js

@@ -1,12 +0,0 @@
-import { constT } from "@harmoniclabs/uplc";
-export class TirVoidT {
-    clone() { return new TirVoidT(); }
-    isConcrete() { return true; }
-    toString() { return "void"; }
-    toAstName() { return "void"; }
-    static toTirTypeKey() { return "void"; }
-    toTirTypeKey() { return TirVoidT.toTirTypeKey(); }
-    toConcreteTirTypeName() { return this.toTirTypeKey(); }
-    hasDataEncoding() { return true; }
-    toUplcConstType() { return constT.unit; }
-}

package/dist/compiler/tir/types/TirStructType.d.ts

@@ -1,68 +0,0 @@
-import { ITirType, TirType } from "./TirType.js";
-import { AstFuncName, TirFuncName } from "../../AstCompiler/scope/AstScope.js";
-import { ConstType } from "@harmoniclabs/uplc";
-export interface ITirStructType extends ITirType {
-    readonly name: string;
-    readonly fileUid: string;
-    readonly constructors: TirStructConstr[];
-    /** points to an array possibly shared with alternative encoding types */
-    readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
-}
-export type TirStructType = TirDataStructType | TirSoPStructType;
-export declare function isTirStructType(thing: any): thing is TirStructType;
-export declare class TirDataStructType implements ITirStructType {
-    readonly name: string;
-    readonly fileUid: string;
-    readonly constructors: TirStructConstr[];
-    /** points to an array possibly shared with alternative encoding types */
-    readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
-    readonly untagged: boolean;
-    constructor(name: string, fileUid: string, constructors: TirStructConstr[], 
-    /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr: Map<AstFuncName, TirFuncName>, untagged?: boolean);
-    hasDataEncoding(): boolean;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    isSingleConstr(): boolean;
-    toString(): string;
-    toAstName(): string;
-    protected _isConcrete: boolean | undefined;
-    isConcrete(): boolean;
-    clone(): TirDataStructType;
-    toUplcConstType(): ConstType;
-}
-export declare class TirSoPStructType implements ITirStructType {
-    readonly name: string;
-    readonly fileUid: string;
-    readonly constructors: TirStructConstr[];
-    /** points to an array possibly shared with alternative encoding types */
-    readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
-    constructor(name: string, fileUid: string, constructors: TirStructConstr[], 
-    /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr: Map<AstFuncName, TirFuncName>);
-    hasDataEncoding(): boolean;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    isSingleConstr(): boolean;
-    toString(): string;
-    toAstName(): string;
-    protected _isConcrete: boolean | undefined;
-    isConcrete(): boolean;
-    clone(): TirSoPStructType;
-    toUplcConstType(): ConstType;
-}
-export declare class TirStructConstr {
-    readonly name: string;
-    readonly fields: TirStructField[];
-    constructor(name: string, fields: TirStructField[]);
-    toString(): string;
-    isConcrete(): boolean;
-    clone(): TirStructConstr;
-}
-export declare class TirStructField {
-    readonly name: string;
-    readonly type: TirType;
-    constructor(name: string, type: TirType);
-    isConcrete(): boolean;
-    clone(): TirStructField;
-}

package/dist/compiler/tir/types/TirStructType.js

@@ -1,128 +0,0 @@
-import { isObject } from "@harmoniclabs/obj-utils";
-import { constT } from "@harmoniclabs/uplc";
-export function isTirStructType(thing) {
-    return isObject(thing) && (thing instanceof TirDataStructType
-        || thing instanceof TirSoPStructType);
-}
-export class TirDataStructType {
-    name;
-    fileUid;
-    constructors;
-    methodNamesPtr;
-    untagged;
-    constructor(name, fileUid, constructors, 
-    /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr, untagged = false) {
-        this.name = name;
-        this.fileUid = fileUid;
-        this.constructors = constructors;
-        this.methodNamesPtr = methodNamesPtr;
-        this.untagged = untagged;
-        this.untagged = false; // always false for now
-    }
-    hasDataEncoding() { return true; }
-    toTirTypeKey() {
-        return "data_" + this.name + "_" + this.fileUid;
-    }
-    toConcreteTirTypeName() {
-        return this.toTirTypeKey();
-    }
-    isSingleConstr() {
-        return this.constructors.length === 1;
-    }
-    toString() {
-        return this.name;
-    }
-    toAstName() {
-        return this.toString();
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = this.constructors.every(c => c.isConcrete());
-        return this._isConcrete;
-    }
-    clone() {
-        const result = new TirDataStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr);
-        result._isConcrete = this._isConcrete;
-        return result;
-    }
-    toUplcConstType() {
-        return constT.data;
-    }
-}
-export class TirSoPStructType {
-    name;
-    fileUid;
-    constructors;
-    methodNamesPtr;
-    constructor(name, fileUid, constructors, 
-    /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr) {
-        this.name = name;
-        this.fileUid = fileUid;
-        this.constructors = constructors;
-        this.methodNamesPtr = methodNamesPtr;
-    }
-    hasDataEncoding() { return false; }
-    toTirTypeKey() {
-        return "sop_" + this.name + "_" + this.fileUid;
-    }
-    toConcreteTirTypeName() {
-        return this.toTirTypeKey();
-    }
-    isSingleConstr() {
-        return this.constructors.length === 1;
-    }
-    toString() {
-        return this.name;
-    }
-    toAstName() {
-        return this.toString();
-    }
-    _isConcrete = undefined;
-    isConcrete() {
-        if (typeof this._isConcrete !== "boolean")
-            this._isConcrete = this.constructors.every(c => c.isConcrete());
-        return this._isConcrete;
-    }
-    clone() {
-        const result = new TirSoPStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr);
-        result._isConcrete = this._isConcrete;
-        return result;
-    }
-    toUplcConstType() {
-        throw new Error("SoP struct cannot be represented as uplc constants.");
-    }
-}
-export class TirStructConstr {
-    name;
-    fields;
-    constructor(name, fields) {
-        this.name = name;
-        this.fields = fields;
-    }
-    toString() {
-        return this.name;
-    }
-    isConcrete() {
-        return this.fields.every(f => f.isConcrete());
-    }
-    clone() {
-        return new TirStructConstr(this.name, this.fields.map(f => f.clone()));
-    }
-}
-export class TirStructField {
-    name;
-    type;
-    constructor(name, type) {
-        this.name = name;
-        this.type = type;
-    }
-    isConcrete() {
-        return this.type.isConcrete();
-    }
-    clone() {
-        return new TirStructField(this.name, this.type.clone());
-    }
-}

package/dist/compiler/tir/types/TirType.d.ts

@@ -1,34 +0,0 @@
-import { TirAliasType } from "./TirAliasType.js";
-import { TirStructType } from "./TirStructType.js";
-import { TirNamedDestructableNativeType, TirNativeType } from "./TirNativeType/TirNativeType.js";
-import { TirTypeParam } from "./TirTypeParam.js";
-import { ConstType } from "@harmoniclabs/uplc";
-export interface ITirType {
-    /** @returns the AST name (human friendly) */
-    toString(): string;
-    /**
-     * @returns the TIR name
-     *
-     * if the type is generic, it returns only the name of the generic type
-     **/
-    toTirTypeKey(): string;
-    /**
-     * @returns the (unapplied) AST name
-     *
-     * if the type is generic, it return only the name of the generic type
-     * and not the type parameters
-     *
-     * if the type is concrete, it returns the same as `toString()`
-     */
-    toAstName(): string;
-    /**
-     * translate to uplc type
-     */
-    toUplcConstType(): ConstType;
-}
-export type TirType = TirNativeType | TirCustomType | TirTypeParam;
-export declare function isTirType(thing: any): thing is TirType;
-export type TirCustomType = TirAliasType | TirStructType;
-export declare function isTirCustomType(thing: any): thing is TirCustomType;
-export type TirNamedDestructableType = TirNamedDestructableNativeType | TirStructType;
-export declare function isTirNamedDestructableType(thing: any): thing is TirNamedDestructableType;

package/dist/compiler/tir/types/TirType.js

@@ -1,16 +0,0 @@
-import { isObject } from "@harmoniclabs/obj-utils";
-import { TirAliasType } from "./TirAliasType.js";
-import { isTirStructType } from "./TirStructType.js";
-import { isTirNamedDestructableNativeType, isTirNativeType } from "./TirNativeType/TirNativeType.js";
-export function isTirType(thing) {
-    return isObject(thing) && (isTirNativeType(thing)
-        || isTirCustomType(thing));
-}
-export function isTirCustomType(thing) {
-    return isObject(thing) && (thing instanceof TirAliasType
-        || isTirStructType(thing));
-}
-export function isTirNamedDestructableType(thing) {
-    return isObject(thing) && (isTirStructType(thing)
-        || isTirNamedDestructableNativeType(thing));
-}