@harmoniclabs/pebble 0.1.0-dev0

package/dist/parser/Precedence.d.ts

@@ -0,0 +1,38 @@
+import { Token } from "../tokenizer/Token.js";
+/**
+ * Operator precedence from least to largest.
+ *
+ * see: http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm#climbing
+ *
+ * The idea is that parseExpr(precedence) recognizes expressions
+ * with precedence less than p
+ *
+**/
+export declare enum Precedence {
+    None = 0,
+    Comma = 1,
+    Spread = 2,
+    Assignment = 3,
+    CaseExpr = 4,
+    Pipe = 5,
+    Conditional = 6,
+    LogicalOr = 7,
+    LogicalAnd = 8,
+    BitwiseOr = 9,
+    BitwiseXor = 10,
+    BitwiseAnd = 11,
+    Equality = 12,
+    Relational = 13,
+    Shift = 14,
+    Additive = 15,
+    Multiplicative = 16,
+    Exponentiated = 17,
+    UnaryPrefix = 18,
+    UnaryPostfix = 19,
+    Call = 20,
+    MemberAccess = 21,
+    Grouping = 22,
+    Litteral = 23
+}
+/** Determines the precedence of a non-starting token. */
+export declare function determinePrecedence(kind: Token): Precedence;

package/dist/parser/Precedence.js

@@ -0,0 +1,98 @@
+import { Token } from "../tokenizer/Token.js";
+/**
+ * Operator precedence from least to largest.
+ *
+ * see: http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm#climbing
+ *
+ * The idea is that parseExpr(precedence) recognizes expressions
+ * with precedence less than p
+ *
+**/
+export var Precedence;
+(function (Precedence) {
+    Precedence[Precedence["None"] = 0] = "None";
+    Precedence[Precedence["Comma"] = 1] = "Comma";
+    Precedence[Precedence["Spread"] = 2] = "Spread";
+    Precedence[Precedence["Assignment"] = 3] = "Assignment";
+    Precedence[Precedence["CaseExpr"] = 4] = "CaseExpr";
+    Precedence[Precedence["Pipe"] = 5] = "Pipe";
+    Precedence[Precedence["Conditional"] = 6] = "Conditional";
+    Precedence[Precedence["LogicalOr"] = 7] = "LogicalOr";
+    Precedence[Precedence["LogicalAnd"] = 8] = "LogicalAnd";
+    Precedence[Precedence["BitwiseOr"] = 9] = "BitwiseOr";
+    Precedence[Precedence["BitwiseXor"] = 10] = "BitwiseXor";
+    Precedence[Precedence["BitwiseAnd"] = 11] = "BitwiseAnd";
+    Precedence[Precedence["Equality"] = 12] = "Equality";
+    Precedence[Precedence["Relational"] = 13] = "Relational";
+    Precedence[Precedence["Shift"] = 14] = "Shift";
+    Precedence[Precedence["Additive"] = 15] = "Additive";
+    Precedence[Precedence["Multiplicative"] = 16] = "Multiplicative";
+    Precedence[Precedence["Exponentiated"] = 17] = "Exponentiated";
+    Precedence[Precedence["UnaryPrefix"] = 18] = "UnaryPrefix";
+    Precedence[Precedence["UnaryPostfix"] = 19] = "UnaryPostfix";
+    Precedence[Precedence["Call"] = 20] = "Call";
+    Precedence[Precedence["MemberAccess"] = 21] = "MemberAccess";
+    Precedence[Precedence["Grouping"] = 22] = "Grouping";
+    Precedence[Precedence["Litteral"] = 23] = "Litteral";
+})(Precedence || (Precedence = {}));
+Object.freeze(Precedence);
+/** Determines the precedence of a non-starting token. */
+export function determinePrecedence(kind) {
+    switch (kind) {
+        case Token.Comma: return Precedence.Comma;
+        case Token.Dot_Dot_Dot: return Precedence.Spread;
+        case Token.Case:
+        // TODO: this would be a special case, `is` is used for `case` expressions
+        // case Token.Is: return Precedence.CaseExpr;
+        case Token.Equals:
+        case Token.Plus_Equals:
+        case Token.Minus_Equals:
+        case Token.Asterisk_Asterisk_Equals:
+        case Token.Asterisk_Equals:
+        case Token.Slash_Equals:
+        case Token.Percent_Equals:
+        case Token.LessThan_LessThan_Equals:
+        case Token.GreaterThan_GreaterThan_Equals:
+        case Token.GreaterThan_GreaterThan_GreaterThan_Equals:
+        case Token.Ampersand_Equals:
+        case Token.Caret_Equals:
+        case Token.Question_Question_Equals:
+        case Token.Bar_Equals: return Precedence.Assignment;
+        case Token.Question: return Precedence.Conditional;
+        case Token.Question_Question: // ?? (null coalescing) same as logical or (left associative)
+        case Token.Bar_Bar: return Precedence.LogicalOr;
+        case Token.Ampersand_Ampersand: return Precedence.LogicalAnd;
+        case Token.Bar: return Precedence.BitwiseOr;
+        case Token.Caret: return Precedence.BitwiseXor;
+        case Token.Ampersand: return Precedence.BitwiseAnd;
+        case Token.Equals_Equals:
+        case Token.Exclamation_Equals:
+        case Token.Equals_Equals_Equals:
+        case Token.Exclamation_Equals_Equals: return Precedence.Equality;
+        case Token.As:
+        // case Token.In:
+        // case Token.InstanceOf:
+        case Token.Is: // TODO: `is` keyword is used (with lower precedence) for `case` expressions
+        case Token.LessThan:
+        case Token.GreaterThan:
+        case Token.LessThan_Equals:
+        case Token.GreaterThan_Equals: return Precedence.Relational;
+        case Token.LessThan_LessThan:
+        case Token.GreaterThan_GreaterThan:
+        case Token.GreaterThan_GreaterThan_GreaterThan: return Precedence.Shift;
+        case Token.Plus:
+        case Token.Minus: return Precedence.Additive;
+        case Token.Asterisk:
+        case Token.Slash:
+        case Token.Percent: return Precedence.Multiplicative;
+        case Token.Asterisk_Asterisk: return Precedence.Exponentiated;
+        case Token.Plus_Plus:
+        case Token.Minus_Minus: return Precedence.UnaryPostfix;
+        case Token.Dot:
+        case Token.Question_Dot:
+        case Token.OpenBracket:
+        case Token.Exclamation: return Precedence.MemberAccess;
+        case Token.HexBytesLiteral: return Precedence.Litteral;
+    }
+    return Precedence.None;
+}

package/dist/parser/hoistStatementsInplace.d.ts

@@ -0,0 +1,14 @@
+import { TopLevelStmt } from "../ast/nodes/statements/PebbleStmt.js";
+/**
+ * final order:
+ *
+ * 1. all imports
+ * 2. (export *) AND (export { ... })
+ * 3. enum declarations (guaranteed no dependencies)
+ * 4. struct and alias declarations
+ * 5. interface declarations
+ * 6. interface implementations
+ * 7. function declarations and var declarations
+ * 8. all other statements
+ */
+export declare function hoistStatementsInplace(stmts: TopLevelStmt[]): void;

package/dist/parser/hoistStatementsInplace.js

@@ -0,0 +1,94 @@
+import { EnumDecl } from "../ast/nodes/statements/declarations/EnumDecl.js";
+import { FuncDecl } from "../ast/nodes/statements/declarations/FuncDecl.js";
+import { InterfaceDecl } from "../ast/nodes/statements/declarations/InterfaceDecl.js";
+import { StructDecl } from "../ast/nodes/statements/declarations/StructDecl.js";
+import { TypeAliasDecl } from "../ast/nodes/statements/declarations/TypeAliasDecl.js";
+import { ExportStarStmt } from "../ast/nodes/statements/ExportStarStmt.js";
+import { ExportImportStmt } from "../ast/nodes/statements/ExportImportStmt.js";
+import { ImportStarStmt } from "../ast/nodes/statements/ImportStarStmt.js";
+import { ImportStmt } from "../ast/nodes/statements/ImportStmt.js";
+import { TypeImplementsStmt } from "../ast/nodes/statements/TypeImplementsStmt.js";
+import { isVarStmt } from "../ast/nodes/statements/VarStmt.js";
+function moveStmt(stmts, fromIdx, toIdx) {
+    if (fromIdx === toIdx)
+        return;
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
+    stmts.splice(toIdx, 0, stmts.splice(fromIdx, 1)[0]);
+}
+/**
+ * final order:
+ *
+ * 1. all imports
+ * 2. (export *) AND (export { ... })
+ * 3. enum declarations (guaranteed no dependencies)
+ * 4. struct and alias declarations
+ * 5. interface declarations
+ * 6. interface implementations
+ * 7. function declarations and var declarations
+ * 8. all other statements
+ */
+export function hoistStatementsInplace(stmts) {
+    const nStmts = stmts.length;
+    let lastSortedIdx = 0;
+    let // avoid unnecessary loops later
+    hasExports = false, hasEnums = false, hasStructs = false, hasInterfaces = false, hasImplements = false, hasFunctions = false;
+    // hoist imports
+    for (let i = 0; i < nStmts; ++i) {
+        const stmt = stmts[i];
+        if (stmt instanceof ImportStmt
+            || stmt instanceof ImportStarStmt)
+            moveStmt(stmts, i, lastSortedIdx++);
+        hasExports = hasExports || stmt instanceof ExportImportStmt || stmt instanceof ExportStarStmt;
+        hasEnums = hasEnums || stmt instanceof EnumDecl;
+        hasStructs = hasStructs || stmt instanceof StructDecl || stmt instanceof TypeAliasDecl;
+        hasInterfaces = hasInterfaces || stmt instanceof InterfaceDecl;
+        hasImplements = hasImplements || stmt instanceof TypeImplementsStmt;
+        hasFunctions = hasFunctions || stmt instanceof FuncDecl || isVarStmt(stmt);
+    }
+    // hoist exports
+    if (hasExports)
+        for (let i = lastSortedIdx; i < nStmts; ++i) {
+            const stmt = stmts[i];
+            if (stmt instanceof ExportImportStmt
+                || stmt instanceof ExportStarStmt)
+                moveStmt(stmts, i, lastSortedIdx++);
+        }
+    // hoist enum
+    if (hasEnums)
+        for (let i = lastSortedIdx; i < nStmts; ++i) {
+            const stmt = stmts[i];
+            if (stmt instanceof EnumDecl)
+                moveStmt(stmts, i, lastSortedIdx++);
+        }
+    // hoist struct and alias declarations
+    if (hasStructs)
+        for (let i = lastSortedIdx; i < nStmts; ++i) {
+            const stmt = stmts[i];
+            if (stmt instanceof StructDecl
+                || stmt instanceof TypeAliasDecl)
+                moveStmt(stmts, i, lastSortedIdx++);
+        }
+    // hoist interface declarations
+    if (hasInterfaces)
+        for (let i = lastSortedIdx; i < nStmts; ++i) {
+            const stmt = stmts[i];
+            if (stmt instanceof InterfaceDecl)
+                moveStmt(stmts, i, lastSortedIdx++);
+        }
+    // hoist interface implementations
+    if (hasImplements)
+        for (let i = lastSortedIdx; i < nStmts; ++i) {
+            const stmt = stmts[i];
+            if (stmt instanceof TypeImplementsStmt)
+                moveStmt(stmts, i, lastSortedIdx++);
+        }
+    // hoist function declarations
+    if (hasFunctions)
+        for (let i = lastSortedIdx; i < nStmts; ++i) {
+            const stmt = stmts[i];
+            if (stmt instanceof FuncDecl
+                || isVarStmt(stmt))
+                moveStmt(stmts, i, lastSortedIdx++);
+        }
+    // all other statements are already in place        
+}

package/dist/parser/index.d.ts

@@ -0,0 +1 @@
+export * from './Parser.js';

package/dist/parser/index.js

@@ -0,0 +1 @@
+export * from './Parser.js';

package/dist/parser/parseFile.d.ts

@@ -0,0 +1,3 @@
+import type { Source } from "../ast/Source/Source.js";
+export declare function parseFile(path: string, src: string, getUid?: () => string, isEntry?: boolean): [Source, import("../diagnostics/DiagnosticMessage.js").DiagnosticMessage[]];
+export declare function parseSource(src: Source): import("../diagnostics/DiagnosticMessage.js").DiagnosticMessage[];

package/dist/parser/parseFile.js

@@ -0,0 +1,8 @@
+import { defaultSymbolForge } from "../compiler/internalVar.js";
+import { Parser } from "./Parser.js";
+export function parseFile(path, src, getUid = defaultSymbolForge.getUid.bind(defaultSymbolForge), isEntry = false) {
+    return Parser.parseFile(path, src, getUid, isEntry);
+}
+export function parseSource(src) {
+    return Parser.parseSource(src);
+}

package/dist/tokenizer/IdentifierHandling.d.ts

@@ -0,0 +1,5 @@
+export declare enum IdentifierHandling {
+    Default = 0,
+    Prefer = 1,
+    Always = 2
+}

package/dist/tokenizer/IdentifierHandling.js

@@ -0,0 +1,6 @@
+export var IdentifierHandling;
+(function (IdentifierHandling) {
+    IdentifierHandling[IdentifierHandling["Default"] = 0] = "Default";
+    IdentifierHandling[IdentifierHandling["Prefer"] = 1] = "Prefer";
+    IdentifierHandling[IdentifierHandling["Always"] = 2] = "Always";
+})(IdentifierHandling || (IdentifierHandling = {}));

package/dist/tokenizer/OnNewLine.d.ts

@@ -0,0 +1,6 @@
+/** Whether a token begins on a new line, if known. */
+export declare enum OnNewLine {
+    No = 0,
+    Yes = 1,
+    Unknown = 2
+}

package/dist/tokenizer/OnNewLine.js

@@ -0,0 +1,8 @@
+/** Whether a token begins on a new line, if known. */
+export var OnNewLine;
+(function (OnNewLine) {
+    OnNewLine[OnNewLine["No"] = 0] = "No";
+    OnNewLine[OnNewLine["Yes"] = 1] = "Yes";
+    OnNewLine[OnNewLine["Unknown"] = 2] = "Unknown";
+})(OnNewLine || (OnNewLine = {}));
+Object.freeze(OnNewLine);

package/dist/tokenizer/Token.d.ts

@@ -0,0 +1,160 @@
+/** Named token types. */
+export declare enum Token {
+    As = 0,
+    Boolean = 1,
+    Break = 2,
+    Struct = 3,
+    Const = 4,
+    Continue = 5,
+    Debugger = 6,
+    Else = 7,
+    Enum = 8,
+    Export = 9,
+    Extends = 10,
+    False = 11,
+    Finally = 12,
+    For = 13,
+    From = 14,
+    Function = 15,
+    If = 16,
+    Implements = 17,
+    Import = 18,
+    Interface = 19,
+    Is = 20,
+    Let = 21,
+    Int = 22,
+    Of = 23,
+    Readonly = 24,
+    Return = 25,
+    Static = 26,
+    This = 27,
+    True = 28,
+    Type = 29,
+    Undefined = 30,
+    Using = 31,
+    Var = 32,
+    Void = 33,
+    While = 34,
+    Match = 35,
+    When = 36,
+    Case = 37,
+    Test = 38,
+    Fail = 39,
+    Assert = 40,
+    /** `{` */
+    OpenBrace = 41,
+    /** `}` */
+    CloseBrace = 42,
+    OpenParen = 43,
+    CloseParen = 44,
+    /** `[` */
+    OpenBracket = 45,
+    /** `]` */
+    CloseBracket = 46,
+    /** `.` */
+    Dot = 47,
+    /** `...` */
+    Dot_Dot_Dot = 48,
+    /** `;` */
+    Semicolon = 49,
+    /** `,` */
+    Comma = 50,
+    /** `<` */
+    LessThan = 51,
+    /** `>` */
+    GreaterThan = 52,
+    /** `<=` */
+    LessThan_Equals = 53,
+    /** `>=` */
+    GreaterThan_Equals = 54,
+    /** `==` */
+    Equals_Equals = 55,
+    /** `!=` */
+    Exclamation_Equals = 56,
+    /** `===` */
+    Equals_Equals_Equals = 57,
+    /** `!==` */
+    Exclamation_Equals_Equals = 58,
+    /** `=>` */
+    FatArrow = 59,
+    /** `+` */
+    Plus = 60,
+    /** `-` */
+    Minus = 61,
+    /** `**` */
+    Asterisk_Asterisk = 62,
+    /** `*` */
+    Asterisk = 63,
+    /** `/` */
+    Slash = 64,
+    /** `%` */
+    Percent = 65,
+    /** `++` */
+    Plus_Plus = 66,
+    /** `--` */
+    Minus_Minus = 67,
+    /** `<<` */
+    LessThan_LessThan = 68,
+    /** `>>` */
+    GreaterThan_GreaterThan = 69,
+    /** `>>>` */
+    GreaterThan_GreaterThan_GreaterThan = 70,
+    /** `+` */
+    Ampersand = 71,
+    /** `|` */
+    Bar = 72,
+    /** `^` */
+    Caret = 73,
+    /** `!` */
+    Exclamation = 74,
+    /** `~` */
+    Tilde = 75,
+    /** `&&` */
+    Ampersand_Ampersand = 76,
+    /** `||` */
+    Bar_Bar = 77,
+    /** `?` */
+    Question = 78,
+    /** `:` */
+    Colon = 79,
+    /** `=` */
+    Equals = 80,
+    Plus_Equals = 81,
+    Minus_Equals = 82,
+    Asterisk_Equals = 83,
+    Asterisk_Asterisk_Equals = 84,
+    Slash_Equals = 85,
+    Percent_Equals = 86,
+    LessThan_LessThan_Equals = 87,
+    GreaterThan_GreaterThan_Equals = 88,
+    GreaterThan_GreaterThan_GreaterThan_Equals = 89,
+    Ampersand_Equals = 90,
+    Bar_Equals = 91,
+    Caret_Equals = 92,
+    At = 93,
+    /** `??=` */
+    Question_Question_Equals = 94,
+    /** `||=` */
+    Bar_Bar_Equals = 95,
+    /** `&&=` */
+    Ampersand_Ampersand_Equals = 96,
+    /** `??` */
+    Question_Question = 97,
+    /** `?.` */
+    Question_Dot = 98,
+    /** `!.` */
+    Exclamation_Dot = 99,
+    Data = 100,
+    Bytes = 101,
+    Optional = 102,
+    List = 103,
+    LinearMap = 104,
+    Runtime = 105,
+    Identifier = 106,
+    StringLiteral = 107,
+    HexBytesLiteral = 108,
+    IntegerLiteral = 109,
+    StringTemplateLiteralQuote = 110,
+    Invalid = 111,
+    EndOfFile = 112
+}

package/dist/tokenizer/Token.js

@@ -0,0 +1,213 @@
+/** Named token types. */
+export var Token;
+(function (Token) {
+    // keywords
+    // discarded: ANY, NEVER, STRING, SYMBOL, LESSTHAN_SLASH, NULL
+    // Abstract,
+    Token[Token["As"] = 0] = "As";
+    // Async,
+    // Await,        
+    Token[Token["Boolean"] = 1] = "Boolean";
+    Token[Token["Break"] = 2] = "Break";
+    // Case,         
+    // Catch,        
+    // Class,        
+    Token[Token["Struct"] = 3] = "Struct";
+    Token[Token["Const"] = 4] = "Const";
+    Token[Token["Continue"] = 5] = "Continue";
+    // Constructor,
+    Token[Token["Debugger"] = 6] = "Debugger";
+    // Declare,
+    // Default,      
+    // Delete,       
+    // Do,           
+    Token[Token["Else"] = 7] = "Else";
+    Token[Token["Enum"] = 8] = "Enum";
+    Token[Token["Export"] = 9] = "Export";
+    Token[Token["Extends"] = 10] = "Extends";
+    Token[Token["False"] = 11] = "False";
+    Token[Token["Finally"] = 12] = "Finally";
+    Token[Token["For"] = 13] = "For";
+    Token[Token["From"] = 14] = "From";
+    Token[Token["Function"] = 15] = "Function";
+    // Get,
+    Token[Token["If"] = 16] = "If";
+    Token[Token["Implements"] = 17] = "Implements";
+    Token[Token["Import"] = 18] = "Import";
+    // In,           
+    // InstanceOf,   
+    Token[Token["Interface"] = 19] = "Interface";
+    Token[Token["Is"] = 20] = "Is";
+    // KeyOf,
+    Token[Token["Let"] = 21] = "Let";
+    // Namespace,
+    // New,          
+    // Null,         
+    Token[Token["Int"] = 22] = "Int";
+    // Number,
+    Token[Token["Of"] = 23] = "Of";
+    // Override,
+    // Package,   
+    // Private,   
+    // Protected, 
+    // Public,    
+    Token[Token["Readonly"] = 24] = "Readonly";
+    Token[Token["Return"] = 25] = "Return";
+    // Set,
+    Token[Token["Static"] = 26] = "Static";
+    // Super,        
+    // Switch,       
+    Token[Token["This"] = 27] = "This";
+    // Throw,        
+    Token[Token["True"] = 28] = "True";
+    // Try,           
+    Token[Token["Type"] = 29] = "Type";
+    // TypeOf,       
+    Token[Token["Undefined"] = 30] = "Undefined";
+    Token[Token["Using"] = 31] = "Using";
+    Token[Token["Var"] = 32] = "Var";
+    Token[Token["Void"] = 33] = "Void";
+    Token[Token["While"] = 34] = "While";
+    // With,         
+    // Yield,        
+    // extra keywords for pebble
+    // https://github.com/tc39/proposal-pattern-matching
+    Token[Token["Match"] = 35] = "Match";
+    Token[Token["When"] = 36] = "When";
+    Token[Token["Case"] = 37] = "Case";
+    Token[Token["Test"] = 38] = "Test";
+    Token[Token["Fail"] = 39] = "Fail";
+    Token[Token["Assert"] = 40] = "Assert";
+    // punctuation
+    /** `{` */
+    Token[Token["OpenBrace"] = 41] = "OpenBrace";
+    /** `}` */
+    Token[Token["CloseBrace"] = 42] = "CloseBrace";
+    Token[Token["OpenParen"] = 43] = "OpenParen";
+    Token[Token["CloseParen"] = 44] = "CloseParen";
+    /** `[` */
+    Token[Token["OpenBracket"] = 45] = "OpenBracket";
+    /** `]` */
+    Token[Token["CloseBracket"] = 46] = "CloseBracket";
+    /** `.` */
+    Token[Token["Dot"] = 47] = "Dot";
+    /** `...` */
+    Token[Token["Dot_Dot_Dot"] = 48] = "Dot_Dot_Dot";
+    /** `;` */
+    Token[Token["Semicolon"] = 49] = "Semicolon";
+    /** `,` */
+    Token[Token["Comma"] = 50] = "Comma";
+    /** `<` */
+    Token[Token["LessThan"] = 51] = "LessThan";
+    /** `>` */
+    Token[Token["GreaterThan"] = 52] = "GreaterThan";
+    /** `<=` */
+    Token[Token["LessThan_Equals"] = 53] = "LessThan_Equals";
+    /** `>=` */
+    Token[Token["GreaterThan_Equals"] = 54] = "GreaterThan_Equals";
+    /** `==` */
+    Token[Token["Equals_Equals"] = 55] = "Equals_Equals";
+    /** `!=` */
+    Token[Token["Exclamation_Equals"] = 56] = "Exclamation_Equals";
+    /** `===` */
+    Token[Token["Equals_Equals_Equals"] = 57] = "Equals_Equals_Equals";
+    /** `!==` */
+    Token[Token["Exclamation_Equals_Equals"] = 58] = "Exclamation_Equals_Equals";
+    /** `=>` */
+    Token[Token["FatArrow"] = 59] = "FatArrow";
+    /** `+` */
+    Token[Token["Plus"] = 60] = "Plus";
+    /** `-` */
+    Token[Token["Minus"] = 61] = "Minus";
+    /** `**` */
+    Token[Token["Asterisk_Asterisk"] = 62] = "Asterisk_Asterisk";
+    /** `*` */
+    Token[Token["Asterisk"] = 63] = "Asterisk";
+    /** `/` */
+    Token[Token["Slash"] = 64] = "Slash";
+    /** `%` */
+    Token[Token["Percent"] = 65] = "Percent";
+    /** `++` */
+    Token[Token["Plus_Plus"] = 66] = "Plus_Plus";
+    /** `--` */
+    Token[Token["Minus_Minus"] = 67] = "Minus_Minus";
+    /** `<<` */
+    Token[Token["LessThan_LessThan"] = 68] = "LessThan_LessThan";
+    /** `>>` */
+    Token[Token["GreaterThan_GreaterThan"] = 69] = "GreaterThan_GreaterThan";
+    /** `>>>` */
+    Token[Token["GreaterThan_GreaterThan_GreaterThan"] = 70] = "GreaterThan_GreaterThan_GreaterThan";
+    /** `+` */
+    Token[Token["Ampersand"] = 71] = "Ampersand";
+    /** `|` */
+    Token[Token["Bar"] = 72] = "Bar";
+    /** `^` */
+    Token[Token["Caret"] = 73] = "Caret";
+    /** `!` */
+    Token[Token["Exclamation"] = 74] = "Exclamation";
+    /** `~` */
+    Token[Token["Tilde"] = 75] = "Tilde";
+    /** `&&` */
+    Token[Token["Ampersand_Ampersand"] = 76] = "Ampersand_Ampersand";
+    /** `||` */
+    Token[Token["Bar_Bar"] = 77] = "Bar_Bar";
+    /** `?` */
+    Token[Token["Question"] = 78] = "Question";
+    /** `:` */
+    Token[Token["Colon"] = 79] = "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["Question_Question_Equals"] = 94] = "Question_Question_Equals";
+    /** `||=` */
+    Token[Token["Bar_Bar_Equals"] = 95] = "Bar_Bar_Equals";
+    /** `&&=` */
+    Token[Token["Ampersand_Ampersand_Equals"] = 96] = "Ampersand_Ampersand_Equals";
+    /** `??` */
+    Token[Token["Question_Question"] = 97] = "Question_Question";
+    /** `?.` */
+    Token[Token["Question_Dot"] = 98] = "Question_Dot";
+    /** `!.` */
+    Token[Token["Exclamation_Dot"] = 99] = "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";
+    // struct decl modifiers
+    // taggedModifier,     // `tagged` data struct
+    Token[Token["Runtime"] = 105] = "Runtime";
+    // literals
+    Token[Token["Identifier"] = 106] = "Identifier";
+    Token[Token["StringLiteral"] = 107] = "StringLiteral";
+    Token[Token["HexBytesLiteral"] = 108] = "HexBytesLiteral";
+    Token[Token["IntegerLiteral"] = 109] = "IntegerLiteral";
+    // FloatLiteral,
+    Token[Token["StringTemplateLiteralQuote"] = 110] = "StringTemplateLiteralQuote";
+    // meta
+    Token[Token["Invalid"] = 111] = "Invalid";
+    Token[Token["EndOfFile"] = 112] = "EndOfFile";
+})(Token || (Token = {}));
+Object.freeze(Token);
+/*
+
+case thing
+    is Constr{} => expr
+    is Other{} => expr
+    is _ => expr;
+
+*/