@harmoniclabs/pebble 0.2.0 → 0.3.1

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

@@ -1,4 +1,5 @@
 export * from "./Optional/index.js";
+export * from "./array.js";
 export * from "./bool.js";
 export * from "./bytes.js";
 export * from "./data.js";
@@ -8,4 +9,5 @@ export * from "./linearMap.js";
 export * from "./linearMapEntry.js";
 export * from "./list.js";
 export * from "./string.js";
+export * from "./value.js";
 export * from "./void.js";

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

@@ -0,0 +1,18 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { ITirType } from "../../TirType.js";
+export declare class TirValueT implements ITirType {
+    clone(): TirValueT;
+    isConcrete(): boolean;
+    toString(): string;
+    toAstName(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    /**
+     * Native `Value` is bidirectionally reachable from `data` via
+     * `unValueData` / `valueData`, so it qualifies as data-encoded for
+     * the purposes of `data struct` field types.
+     */
+    hasDataEncoding(): boolean;
+    toUplcConstType(): ConstType;
+}

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

@@ -0,0 +1,17 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirValueT {
+    clone() { return new TirValueT(); }
+    isConcrete() { return true; }
+    toString() { return "Value"; }
+    toAstName() { return "Value"; }
+    static toTirTypeKey() { return "Value"; }
+    toTirTypeKey() { return TirValueT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    /**
+     * Native `Value` is bidirectionally reachable from `data` via
+     * `unValueData` / `valueData`, so it qualifies as data-encoded for
+     * the purposes of `data struct` field types.
+     */
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.value; }
+}

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

@@ -27,7 +27,12 @@ export class TirDataStructType {
         this.constructors = constructors;
         this.methodNamesPtr = methodNamesPtr;
         this.untagged = untagged;
-        this.untagged = false; // always false for now
+        // `untagged === true` requires a single constructor — its runtime
+        // form is `listData(fields)` instead of `constrData(idx, fields)`.
+        if (untagged && constructors.length !== 1) {
+            throw new Error("untagged data struct must have exactly one constructor; got "
+                + constructors.length);
+        }
         this.narrowedFromParentCtorIdxs = narrowedFromParentCtorIdxs;
     }
     hasDataEncoding() { return true; }

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

@@ -1,5 +1,6 @@
 import { TirAliasType } from "./TirAliasType.js";
 import { TirStructType } from "./TirStructType.js";
+import { TirEnumType } from "./TirEnumType.js";
 import { TirNamedDestructableNativeType, TirNativeType } from "./TirNativeType/TirNativeType.js";
 import { TirTypeParam } from "./TirTypeParam.js";
 import { ConstType } from "@harmoniclabs/uplc";
@@ -28,7 +29,7 @@ export interface ITirType {
 }
 export type TirType = TirNativeType | TirCustomType | TirTypeParam;
 export declare function isTirType(thing: any): thing is TirType;
-export type TirCustomType = TirAliasType | TirStructType;
+export type TirCustomType = TirAliasType | TirStructType | TirEnumType;
 export declare function isTirCustomType(thing: any): thing is TirCustomType;
-export type TirNamedDestructableType = TirNamedDestructableNativeType | TirStructType;
+export type TirNamedDestructableType = TirNamedDestructableNativeType | TirStructType | TirEnumType;
 export declare function isTirNamedDestructableType(thing: any): thing is TirNamedDestructableType;

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

@@ -1,6 +1,7 @@
 import { isObject } from "@harmoniclabs/obj-utils";
 import { TirAliasType } from "./TirAliasType.js";
 import { isTirStructType } from "./TirStructType.js";
+import { isTirEnumType } from "./TirEnumType.js";
 import { isTirNamedDestructableNativeType, isTirNativeType } from "./TirNativeType/TirNativeType.js";
 import { TirTypeParam } from "./TirTypeParam.js";
 export function isTirType(thing) {
@@ -10,9 +11,11 @@ export function isTirType(thing) {
 }
 export function isTirCustomType(thing) {
     return isObject(thing) && (thing instanceof TirAliasType
-        || isTirStructType(thing));
+        || isTirStructType(thing)
+        || isTirEnumType(thing));
 }
 export function isTirNamedDestructableType(thing) {
     return isObject(thing) && (isTirStructType(thing)
+        || isTirEnumType(thing)
         || isTirNamedDestructableNativeType(thing));
 }

package/dist/compiler/tir/types/utils/canAssignTo.js

@@ -5,6 +5,8 @@ import { TirBytesT } from "../TirNativeType/native/bytes.js";
 import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirFuncT } from "../TirNativeType/native/function.js";
 import { TirIntT } from "../TirNativeType/native/int.js";
+import { TirArrayT } from "../TirNativeType/native/array.js";
+import { TirValueT } from "../TirNativeType/native/value.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../TirNativeType/native/list.js";
@@ -13,6 +15,7 @@ import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
 import { TirStringT } from "../TirNativeType/native/string.js";
 import { TirVoidT } from "../TirNativeType/native/void.js";
 import { isTirStructType, TirDataStructType, TirSoPStructType } from "../TirStructType.js";
+import { TirEnumType } from "../TirEnumType.js";
 import { isTirNamedDestructableType } from "../TirType.js";
 import { TirTypeParam } from "../TirTypeParam.js";
 import { canCastToData } from "./canCastTo.js";
@@ -108,6 +111,10 @@ function uncheckedGetCanAssign(a, b, symbols) {
     if (b instanceof TirIntT) {
         if (a instanceof TirIntT)
             return CanAssign.Yes;
+        // enum runtime representation is a plain int, so an enum value can
+        // flow directly into any int operation.
+        if (a instanceof TirEnumType)
+            return CanAssign.Yes;
         if (a instanceof TirDataT)
             return CanAssign.RequiresExplicitCast;
         return CanAssign.No;
@@ -218,6 +225,19 @@ function uncheckedGetCanAssign(a, b, symbols) {
     }
     if (isTirStructType(a))
         return CanAssign.No;
+    if (b instanceof TirEnumType) {
+        if (a instanceof TirEnumType
+            && a.toTirTypeKey() === b.toTirTypeKey())
+            return CanAssign.Yes;
+        // `data` (e.g. datum/redeemer) can be decoded to an enum with an
+        // explicit cast; plain `int` cannot — there is no way to statically
+        // verify it is a valid tag.
+        if (a instanceof TirDataT)
+            return CanAssign.RequiresExplicitCast;
+        return CanAssign.No;
+    }
+    if (a instanceof TirEnumType)
+        return CanAssign.No;
     if (b instanceof TirFuncT) {
         if (!(a instanceof TirFuncT
             && a.argTypes.length === b.argTypes.length))
@@ -239,6 +259,14 @@ function uncheckedGetCanAssign(a, b, symbols) {
         return a instanceof TirBlsG2T ? CanAssign.Yes : CanAssign.No;
     if (b instanceof TirMlResultT)
         return a instanceof TirMlResultT ? CanAssign.Yes : CanAssign.No;
+    // Native Value / Array<T>
+    if (b instanceof TirValueT)
+        return a instanceof TirValueT ? CanAssign.Yes : CanAssign.No;
+    if (b instanceof TirArrayT) {
+        if (!(a instanceof TirArrayT))
+            return CanAssign.No;
+        return uncheckedGetCanAssign(a.typeArg, b.typeArg, symbols);
+    }
     const tsEnsureExhautstiveCheck = b;
     return CanAssign.No;
 }

package/dist/compiler/tir/types/utils/canCastTo.js

@@ -12,6 +12,7 @@ import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
 import { TirStringT } from "../TirNativeType/native/string.js";
 import { TirVoidT } from "../TirNativeType/native/void.js";
 import { isTirStructType, TirDataStructType } from "../TirStructType.js";
+import { TirEnumType } from "../TirEnumType.js";
 import { CanAssign, getCanAssign } from "./canAssignTo.js";
 export function canCastTo(a, b) {
     if (!(a.isConcrete()
@@ -52,6 +53,8 @@ export function canCastTo(a, b) {
     if (b instanceof TirIntT) {
         if (a instanceof TirIntT)
             return true;
+        if (a instanceof TirEnumType)
+            return true; // enum is an int at runtime
         if (a instanceof TirDataT)
             return true;
         if (a instanceof TirBoolT)
@@ -113,6 +116,15 @@ export function canCastTo(a, b) {
         }
         return false;
     }
+    if (b instanceof TirEnumType) {
+        if (a instanceof TirEnumType)
+            return a.toTirTypeKey() === b.toTirTypeKey();
+        // only `data` (e.g. datum/redeemer decoding) can be cast to enum;
+        // plain `int` cannot — there is no way to verify it is a valid tag.
+        if (a instanceof TirDataT)
+            return true;
+        return false;
+    }
     if (b instanceof TirFuncT) {
         if (!(a instanceof TirFuncT))
             return false;
@@ -148,7 +160,8 @@ export function canCastToData(a) {
         || a instanceof TirStringT
         || a instanceof TirBoolT
         || a instanceof TirDataOptT
-        || a instanceof TirDataStructType)
+        || a instanceof TirDataStructType
+        || a instanceof TirEnumType)
         return true;
     if (a instanceof TirLinearMapT) {
         const key = canCastToData(a.keyTypeArg);

package/dist/compiler/tir/types/utils/getDeconstructableType.d.ts

@@ -1,3 +1,4 @@
+import { TirEnumType } from "../TirEnumType.js";
 import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirListT } from "../TirNativeType/native/list.js";
@@ -5,5 +6,5 @@ import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
 import { TirStructType } from "../TirStructType.js";
 import { TirType } from "../TirType.js";
-export type DeconstructableTirType = TirStructType | TirSopOptT | TirDataOptT | TirListT | TirLinearMapT | TirDataT;
+export type DeconstructableTirType = TirStructType | TirEnumType | TirSopOptT | TirDataOptT | TirListT | TirLinearMapT | TirDataT;
 export declare function getDeconstructableType(type: TirType): DeconstructableTirType | undefined;

package/dist/compiler/tir/types/utils/getDeconstructableType.js

@@ -1,4 +1,5 @@
 import { TirAliasType } from "../TirAliasType.js";
+import { TirEnumType } from "../TirEnumType.js";
 import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirListT } from "../TirNativeType/native/list.js";
@@ -9,6 +10,7 @@ export function getDeconstructableType(type) {
     while (type instanceof TirAliasType)
         type = type.aliased;
     if (isTirStructType(type)
+        || type instanceof TirEnumType
         || type instanceof TirSopOptT
         || type instanceof TirDataOptT
         || type instanceof TirListT

package/dist/compiler/tir/types/utils/inferTypeArgs.js

@@ -1,3 +1,4 @@
+import { TirArrayT } from "../TirNativeType/native/array.js";
 import { TirFuncT } from "../TirNativeType/native/function.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
@@ -34,6 +35,9 @@ export function inferTypeArgs(formal, actual, env) {
     if (formal instanceof TirListT && actual instanceof TirListT) {
         return inferTypeArgs(formal.typeArg, actual.typeArg, env);
     }
+    if (formal instanceof TirArrayT && actual instanceof TirArrayT) {
+        return inferTypeArgs(formal.typeArg, actual.typeArg, env);
+    }
     if (formal instanceof TirFuncT && actual instanceof TirFuncT) {
         if (formal.argTypes.length !== actual.argTypes.length)
             return false;

package/dist/compiler/tir/types/utils/normalizeEnumToInt.d.ts

@@ -0,0 +1,10 @@
+import { TirIntT } from "../TirNativeType/native/int.js";
+import { TirType } from "../TirType.js";
+/**
+ * If `t` is an enum type (or alias of one), returns the shared `int` type
+ * (since enums lower to plain ints at runtime). Otherwise returns `t`.
+ *
+ * Use this to relax type checks for binary operators that treat enums as
+ * integers (arithmetic, comparison, equality).
+ */
+export declare function normalizeEnumToInt(t: TirType, int_t: TirIntT): TirType;

package/dist/compiler/tir/types/utils/normalizeEnumToInt.js

@@ -0,0 +1,17 @@
+import { TirAliasType } from "../TirAliasType.js";
+import { TirEnumType } from "../TirEnumType.js";
+/**
+ * If `t` is an enum type (or alias of one), returns the shared `int` type
+ * (since enums lower to plain ints at runtime). Otherwise returns `t`.
+ *
+ * Use this to relax type checks for binary operators that treat enums as
+ * integers (arithmetic, comparison, equality).
+ */
+export function normalizeEnumToInt(t, int_t) {
+    let probe = t;
+    while (probe instanceof TirAliasType)
+        probe = probe.aliased;
+    if (probe instanceof TirEnumType)
+        return int_t;
+    return t;
+}

package/dist/compiler/tir/types/utils/substituteTypeParams.js

@@ -1,4 +1,5 @@
 import { TirAliasType } from "../TirAliasType.js";
+import { TirArrayT } from "../TirNativeType/native/array.js";
 import { TirFuncT } from "../TirNativeType/native/function.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
@@ -23,6 +24,10 @@ export function substituteTypeParams(t, subst) {
         const sub = substituteTypeParams(t.typeArg, subst);
         return sub === t.typeArg ? t : new TirListT(sub);
     }
+    if (t instanceof TirArrayT) {
+        const sub = substituteTypeParams(t.typeArg, subst);
+        return sub === t.typeArg ? t : new TirArrayT(sub);
+    }
     if (t instanceof TirFuncT) {
         let changed = false;
         const newArgs = t.argTypes.map(a => {

package/dist/diagnostics/diagnosticMessages.generated.d.ts

@@ -283,6 +283,11 @@ export declare enum DiagnosticCode {
     _private_modifier_is_only_allowed_on_declarations_inside_a_namespace = 30003,
     Namespaces_cannot_be_declared_here = 30004,
     _0_is_not_a_namespace = 30005,
+    Enum_members_cannot_have_explicit_values = 30100,
+    Duplicate_enum_member_0 = 30101,
+    Enum_must_have_at_least_one_member = 30102,
+    Property_0_is_not_a_member_of_enum_1 = 30103,
+    Enum_member_pattern_cannot_have_fields = 30104,
     Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong = 42069
 }
 /** Translates a diagnostic code to its respective string. */

package/dist/diagnostics/diagnosticMessages.generated.js

@@ -285,6 +285,11 @@ export var DiagnosticCode;
     DiagnosticCode[DiagnosticCode["_private_modifier_is_only_allowed_on_declarations_inside_a_namespace"] = 30003] = "_private_modifier_is_only_allowed_on_declarations_inside_a_namespace";
     DiagnosticCode[DiagnosticCode["Namespaces_cannot_be_declared_here"] = 30004] = "Namespaces_cannot_be_declared_here";
     DiagnosticCode[DiagnosticCode["_0_is_not_a_namespace"] = 30005] = "_0_is_not_a_namespace";
+    DiagnosticCode[DiagnosticCode["Enum_members_cannot_have_explicit_values"] = 30100] = "Enum_members_cannot_have_explicit_values";
+    DiagnosticCode[DiagnosticCode["Duplicate_enum_member_0"] = 30101] = "Duplicate_enum_member_0";
+    DiagnosticCode[DiagnosticCode["Enum_must_have_at_least_one_member"] = 30102] = "Enum_must_have_at_least_one_member";
+    DiagnosticCode[DiagnosticCode["Property_0_is_not_a_member_of_enum_1"] = 30103] = "Property_0_is_not_a_member_of_enum_1";
+    DiagnosticCode[DiagnosticCode["Enum_member_pattern_cannot_have_fields"] = 30104] = "Enum_member_pattern_cannot_have_fields";
     DiagnosticCode[DiagnosticCode["Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong"] = 42069] = "Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong";
 })(DiagnosticCode || (DiagnosticCode = {}));
 /** Translates a diagnostic code to its respective string. */
@@ -573,6 +578,11 @@ export function diagnosticCodeToString(code) {
         case 30003: return "'private' modifier is only allowed on declarations inside a namespace.";
         case 30004: return "Namespaces cannot be declared here.";
         case 30005: return "'{0}' is not a namespace.";
+        case 30100: return "Enum members cannot have explicit values.";
+        case 30101: return "Duplicate enum member '{0}'.";
+        case 30102: return "Enum must have at least one member.";
+        case 30103: return "Property '{0}' is not a member of enum '{1}'.";
+        case 30104: return "Enum member pattern cannot have fields.";
         case 42069: return "Dev was too lazy to add a prooper error message. Something went wrong";
         default: return "";
     }

package/dist/parser/Parser.js

@@ -178,13 +178,19 @@ export class Parser extends DiagnosticEmitter {
             case Token.Data: {
                 // `next()` skips `data` keyword
                 tn.next();
+                let extraFlags = StructDeclAstFlags.onlyDataEncoding;
+                // accept `data untagged struct ...`
+                if (tn.peek() === Token.Untagged) {
+                    tn.next();
+                    extraFlags |= StructDeclAstFlags.untagged;
+                }
                 // positions on (expected) `struct` keyword
                 if (tn.peek() !== Token.Struct) {
                     console.error(Token[tn.peek()]);
                     return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
                 }
                 tn.next(); // skip `struct`
-                statement = this.parseStruct(StructDeclAstFlags.onlyDataEncoding, flags, startPos);
+                statement = this.parseStruct(extraFlags, flags, startPos);
                 break;
             }
             case Token.Runtime: {
@@ -203,6 +209,22 @@ export class Parser extends DiagnosticEmitter {
                 statement = this.parseStruct(StructDeclAstFlags.none, flags, startPos);
                 break;
             }
+            case Token.Untagged: {
+                // `untagged` keyword forces listData encoding (single ctor).
+                // Accept: `untagged struct ...` or `untagged data struct ...`.
+                tn.next(); // skip `untagged`
+                let extraFlags = StructDeclAstFlags.untagged;
+                if (tn.peek() === Token.Data) {
+                    tn.next(); // skip `data`
+                    extraFlags |= StructDeclAstFlags.onlyDataEncoding;
+                }
+                if (tn.peek() !== Token.Struct) {
+                    return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
+                }
+                tn.next(); // skip `struct`
+                statement = this.parseStruct(extraFlags, flags, startPos);
+                break;
+            }
             case Token.Interface: {
                 tn.next();
                 statement = this.parseInterface(flags, startPos);
@@ -884,7 +906,7 @@ export class Parser extends DiagnosticEmitter {
             [
                 new StructConstrDecl(new Identifier(name.text, name.range), [], // fields
                 range)
-            ], structDeclFlags | StructDeclAstFlags.untaggedSingleConstructor, range.clone());
+            ], structDeclFlags | StructDeclAstFlags.shortcutSingleConstructor, range.clone());
         }
         let constrIdentifier = undefined;
         // in case of single constr shortcut
@@ -905,7 +927,7 @@ export class Parser extends DiagnosticEmitter {
             tn.skip(Token.Semicolon); // if any
             return new StructDecl(name, typeParams, [
                 new StructConstrDecl(new Identifier(name.text, name.range), fields, tn.range(startPos, tn.pos))
-            ], structDeclFlags | StructDeclAstFlags.untaggedSingleConstructor, tn.range(startPos, tn.pos));
+            ], structDeclFlags | StructDeclAstFlags.shortcutSingleConstructor, tn.range(startPos, tn.pos));
         }
         const constrFields = this.parseStructConstrFields(flags);
         if (!Array.isArray(constrFields))
@@ -1885,17 +1907,14 @@ export class Parser extends DiagnosticEmitter {
         const expr = this.parseExpr(Precedence.Relational + 1);
         if (!expr)
             return undefined;
-        let noPatternCaseSeen = false;
         const cases = new Array();
         while (tn.skip(Token.Is)) {
-            if (noPatternCaseSeen)
-                return this.error(DiagnosticCode.This_case_will_never_be_evaluated_because_all_patterns_will_be_catched_before, tn.range());
             const startPos = tn.tokenPos;
             const matcher = this._parseVarDecl(CommonFlags.Const);
             if (!matcher)
                 return undefined;
-            if (matcher instanceof SimpleVarDecl)
-                noPatternCaseSeen = true;
+            // SimpleVarDecl patterns are validated by the AstCompiler, which
+            // has type info (enum-member promotion vs invalid catch-all).
             if (matcher.initExpr || matcher.type)
                 return this.error(DiagnosticCode.Patterns_may_not_have_initializers_or_explicit_types, matcher.initExpr ? matcher.initExpr.range : matcher.type.range);
             if (!tn.skip(Token.FatArrow))
@@ -2626,7 +2645,6 @@ export class Parser extends DiagnosticEmitter {
             return this.error(DiagnosticCode.Expression_expected, tn.range(startPos - 5, startPos));
         if (!tn.skip(Token.OpenBrace))
             return this.error(DiagnosticCode._0_expected, tn.range(), "{");
-        let noPatternCaseSeen = false;
         const cases = new Array();
         while (!tn.skip(Token.CloseBrace)
             && tn.peek() !== Token.Else) {
@@ -2637,10 +2655,8 @@ export class Parser extends DiagnosticEmitter {
             const pattern = this._parseVarDecl(CommonFlags.Const, true);
             if (!pattern)
                 return this.error(DiagnosticCode.Pattern_expected, tn.range());
-            if (noPatternCaseSeen)
-                return this.error(DiagnosticCode.This_case_will_never_be_evaluated_because_all_patterns_will_be_catched_before, pattern.range);
-            if (pattern instanceof SimpleVarDecl)
-                noPatternCaseSeen = true;
+            // SimpleVarDecl patterns are validated by the AstCompiler, which
+            // has type info (enum-member promotion vs invalid catch-all).
             if (!tn.skip(Token.Colon))
                 return this.error(DiagnosticCode._0_expected, tn.range(), ":");
             const statePreBody = tn.mark();

package/dist/tokenizer/Token.d.ts

@@ -164,11 +164,12 @@ export declare enum Token {
     List = 117,
     LinearMap = 118,
     Runtime = 119,
-    Identifier = 120,
-    StringLiteral = 121,
-    HexBytesLiteral = 122,
-    IntegerLiteral = 123,
-    StringTemplateLiteralQuote = 124,
-    Invalid = 125,
-    EndOfFile = 126
+    Untagged = 120,
+    Identifier = 121,
+    StringLiteral = 122,
+    HexBytesLiteral = 123,
+    IntegerLiteral = 124,
+    StringTemplateLiteralQuote = 125,
+    Invalid = 126,
+    EndOfFile = 127
 }

package/dist/tokenizer/Token.js

@@ -204,16 +204,17 @@ export var Token;
     // struct decl modifiers
     // taggedModifier,     // `tagged` data struct
     Token[Token["Runtime"] = 119] = "Runtime";
+    Token[Token["Untagged"] = 120] = "Untagged";
     // literals
-    Token[Token["Identifier"] = 120] = "Identifier";
-    Token[Token["StringLiteral"] = 121] = "StringLiteral";
-    Token[Token["HexBytesLiteral"] = 122] = "HexBytesLiteral";
-    Token[Token["IntegerLiteral"] = 123] = "IntegerLiteral";
+    Token[Token["Identifier"] = 121] = "Identifier";
+    Token[Token["StringLiteral"] = 122] = "StringLiteral";
+    Token[Token["HexBytesLiteral"] = 123] = "HexBytesLiteral";
+    Token[Token["IntegerLiteral"] = 124] = "IntegerLiteral";
     // FloatLiteral,
-    Token[Token["StringTemplateLiteralQuote"] = 124] = "StringTemplateLiteralQuote";
+    Token[Token["StringTemplateLiteralQuote"] = 125] = "StringTemplateLiteralQuote";
     // meta
-    Token[Token["Invalid"] = 125] = "Invalid";
-    Token[Token["EndOfFile"] = 126] = "EndOfFile";
+    Token[Token["Invalid"] = 126] = "Invalid";
+    Token[Token["EndOfFile"] = 127] = "EndOfFile";
 })(Token || (Token = {}));
 Object.freeze(Token);
 /*

package/dist/tokenizer/utils/tokenFromKeyword.js

@@ -221,6 +221,8 @@ export function tokenFromKeyword(text) {
                 return Token.Undefined;
             if (text === "using")
                 return Token.Using;
+            if (text === "untagged")
+                return Token.Untagged;
             break;
         }
         case 118 /* CharCode.v */: {

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const COMPILER_VERSION = "0.2.0";
+export declare const COMPILER_VERSION = "0.3.1";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // This file is auto-generated by scripts/genVersion.js. Do not edit.
-export const COMPILER_VERSION = "0.2.0";
+export const COMPILER_VERSION = "0.3.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -53,12 +53,12 @@
   "homepage": "https://github.com/HarmonicLabs/pebble#readme",
   "dependencies": {
     "@harmoniclabs/bigint-utils": "^1.0.0",
-    "@harmoniclabs/cardano-costmodels-ts": "^1.4.0",
+    "@harmoniclabs/cardano-costmodels-ts": "^1.6.1",
     "@harmoniclabs/cbor": "^2.0.1",
     "@harmoniclabs/crypto": "^0.3.0",
     "@harmoniclabs/obj-utils": "^1.0.0",
     "@harmoniclabs/plutus-data": "^2.0.1",
-    "@harmoniclabs/plutus-machine": "^3.0.0",
+    "@harmoniclabs/plutus-machine": "^3.0.3",
     "@harmoniclabs/uint8array-utils": "^1.0.4",
     "@harmoniclabs/uplc": "^2.0.5"
   },

package/dist/IR/tree_utils/_ir_lazyChooseList.d.ts

@@ -1,3 +0,0 @@
-import { IRForced } from "../IRNodes/IRForced.js";
-import type { IRTerm } from "../IRTerm.js";
-export declare function _ir_lazyChooseList(listTerm: IRTerm, caseNil: IRTerm, caseCons: IRTerm): IRForced;

package/dist/IR/tree_utils/_ir_lazyChooseList.js

@@ -1,7 +0,0 @@
-import { _ir_apps } from "../IRNodes/IRApp.js";
-import { IRDelayed } from "../IRNodes/IRDelayed.js";
-import { IRForced } from "../IRNodes/IRForced.js";
-import { IRNative } from "../IRNodes/IRNative/index.js";
-export function _ir_lazyChooseList(listTerm, caseNil, caseCons) {
-    return new IRForced(_ir_apps(IRNative.strictChooseList, listTerm, new IRDelayed(caseNil), new IRDelayed(caseCons)));
-}