Universal WebAssembly Compiler

Multi-Language Support

TypeScript, JavaScript, Rust, C-like, Python-like syntax - all compile to WASM.

Full Compiler Pipeline

Lexer → Parser → Type Checker → IR → Optimizer → WAT → WASM binary.

Advanced Optimizations

Constant folding, dead code elimination, strength reduction, peephole opts.

Rich Type System

Generics, unions, tuples, pointers, references, optionals, and more.

\n\n

\n Source Code\n \n

\n \n \n

\n \n

\n Compilation Output\n

\n \n \n \n

Compiled WASM (Base64) will appear here...

Generated WAT will appear here...

Compiler diagnostics will appear here...

\n \n

\n Runtime Execution\n

\n \n \n \n \n \n \n

\n\n \n\n`;\n\n// HTTP Handler\nexport default async function handle(req: Request): Promise {\n const method = req.method.toUpperCase();\n\n if (method === \"OPTIONS\") {\n return new Response(null, { status: 204, headers: corsHeaders });\n }\n\n if (method === \"POST\") {\n let payload: CompileRequest;\n try {\n payload = await req.json() as CompileRequest;\n } catch {\n return jsonResponse({\n ok: false,\n language: \"unknown\",\n diagnostics: [],\n error: \"Invalid JSON body\",\n }, 400);\n }\n\n if (!payload.code || !payload.language) {\n return jsonResponse({\n ok: false,\n language: \"unknown\",\n diagnostics: [],\n error: \"Missing 'code' or 'language'\",\n }, 400);\n }\n\n const lang = normalizeLanguage(payload.language);\n\n if (lang === \"wat\") {\n const result = await compileWat(payload.code);\n return jsonResponse(result, result.ok ? 200 : 400);\n }\n\n const compiler = new Compiler();\n const result = await compiler.compile(payload.code, payload.optimize !== false);\n return jsonResponse(result, result.ok ? 200 : 400);\n }\n\n if (method === \"GET\") {\n return new Response(demoHtml, {\n status: 200,\n headers: { ...corsHeaders, \"Content-Type\": \"text/html; charset=utf-8\" },\n });\n }\n\n return new Response(\"Method Not Allowed\", { status: 405, headers: corsHeaders });\n}",[],[171],{"_102":180,"_95":181,"_151":182,"_153":-5,"_154":136,"_155":183,"_156":157,"_104":184,"_99":159,"_160":161,"_162":185,"_164":22,"_165":-5,"_166":186,"_98":187},"301e2e10-d1fa-11f0-8a24-42dde27851f2","compiler_types.ts","61306c88-d1f6-11f0-803b-42dde27851f2",36,["D",1764953292761],"import wabtInit from \"https://esm.sh/wabt@1.0.36\";\nimport { depth, value, stmt, err, local, name, params, returnType, param, index, and, declarations, exp, global, struct, if, s, symbol, arg, results, 0, ref, a, b, prev, val, shift, mem, sig, Compiler, lexer, parser, optimizer, wabt } from \"https://esm.town/v/ypiy/untitled-2689/compiler_semantic.ts\";\nimport { t, type, args, func, result, i, binary, l, add, min, max, sign, x, y, sum, num, log, div, compile, res, data, module, handle, method, compiler } from \"https://esm.town/v/ypiy/untitled-2689/compiler_server.ts\";\n\n// main.ts — Universal WebAssembly Compiler\n// A complete compiler infrastructure with lexer, parser, type checker, IR, optimizer, and code generator\n\nimport wabtInit from \"https://esm.sh/wabt@1.0.36\";\n\n// ============================================================================\n// SECTION 1: TYPE SYSTEM\n// ============================================================================\n\nexport type WasmType = \"i32\" | \"i64\" | \"f32\" | \"f64\" | \"v128\" | \"funcref\" | \"externref\" | \"void\";\n\nexport interface FunctionType {\n params: WasmType[];\n results: WasmType[];\n}\n\nexport interface ArrayType {\n elementType: WasmType;\n mutable: boolean;\n}\n\nexport interface StructField {\n name: string;\n type: WasmType;\n mutable: boolean;\n}\n\nexport interface StructType {\n name: string;\n fields: StructField[];\n}\n\nexport type TypeInfo = \n | { kind: \"primitive\"; type: WasmType }\n | { kind: \"function\"; type: FunctionType }\n | { kind: \"array\"; type: ArrayType }\n | { kind: \"struct\"; type: StructType }\n | { kind: \"generic\"; name: string; constraints: WasmType[] };\n\n// ============================================================================\n// SECTION 2: LEXER / TOKENIZER\n// ============================================================================\n\nexport enum TokenType {\n // Literals\n INTEGER, FLOAT, STRING, CHAR, BOOLEAN,\n // Identifiers & Keywords\n IDENTIFIER, KEYWORD,\n // Operators\n PLUS, MINUS, STAR, SLASH, PERCENT, AMPERSAND, PIPE, CARET, TILDE,\n LESS, GREATER, LESS_EQUAL, GREATER_EQUAL, EQUAL_EQUAL, BANG_EQUAL,\n AMPERSAND_AMPERSAND, PIPE_PIPE, LESS_LESS, GREATER_GREATER, GREATER_GREATER_GREATER,\n EQUAL, PLUS_EQUAL, MINUS_EQUAL, STAR_EQUAL, SLASH_EQUAL, PERCENT_EQUAL,\n AMPERSAND_EQUAL, PIPE_EQUAL, CARET_EQUAL, LESS_LESS_EQUAL, GREATER_GREATER_EQUAL,\n PLUS_PLUS, MINUS_MINUS, BANG, QUESTION, COLON,\n // Delimiters\n LPAREN, RPAREN, LBRACE, RBRACE, LBRACKET, RBRACKET,\n COMMA, DOT, SEMICOLON, ARROW, FAT_ARROW, DOUBLE_COLON,\n // Special\n EOF, NEWLINE, COMMENT,\n}\n\nexport const KEYWORDS = new Set([\n \"let\", \"const\", \"var\", \"mut\",\n \"function\", \"fn\", \"func\", \"def\", \"proc\",\n \"return\", \"yield\",\n \"if\", \"else\", \"elif\", \"elseif\", \"then\",\n \"for\", \"while\", \"do\", \"loop\", \"break\", \"continue\",\n \"switch\", \"case\", \"default\", \"match\", \"when\",\n \"class\", \"struct\", \"interface\", \"trait\", \"impl\", \"type\", \"enum\", \"union\",\n \"import\", \"export\", \"from\", \"as\", \"module\", \"package\", \"namespace\",\n \"public\", \"private\", \"protected\", \"static\", \"final\", \"abstract\", \"virtual\", \"override\",\n \"new\", \"delete\", \"this\", \"self\", \"super\",\n \"true\", \"false\", \"null\", \"nil\", \"none\", \"undefined\", \"void\",\n \"async\", \"await\", \"spawn\", \"select\", \"channel\",\n \"try\", \"catch\", \"finally\", \"throw\", \"raise\", \"except\", \"panic\", \"recover\",\n \"in\", \"is\", \"not\", \"and\", \"or\", \"xor\",\n \"sizeof\", \"typeof\", \"instanceof\", \"alignof\", \"offsetof\",\n \"inline\", \"extern\", \"volatile\", \"atomic\", \"synchronized\",\n \"i8\", \"i16\", \"i32\", \"i64\", \"i128\",\n \"u8\", \"u16\", \"u32\", \"u64\", \"u128\",\n \"f16\", \"f32\", \"f64\", \"f128\",\n \"int\", \"uint\", \"float\", \"double\", \"bool\", \"boolean\", \"byte\", \"char\", \"string\",\n \"number\", \"any\", \"never\", \"unknown\", \"object\",\n \"array\", \"vec\", \"list\", \"map\", \"set\", \"dict\", \"tuple\",\n \"ref\", \"ptr\", \"box\", \"rc\", \"arc\", \"weak\", \"unique\", \"shared\",\n \"memory\", \"table\", \"global\", \"local\", \"data\", \"elem\", \"start\",\n]);\n\nexport interface Token {\n type: TokenType;\n value: string | number | boolean | null;\n lexeme: string;\n line: number;\n column: number;\n offset: number;\n}\n\nexport interface LexerError {\n message: string;\n line: number;\n column: number;\n offset: number;\n}\n\nexport class Lexer {\n private source: string;\n private tokens: Token[] = [];\n private errors: LexerError[] = [];\n private start = 0;\n private current = 0;\n private line = 1;\n private column = 1;\n private lineStart = 0;\n\n constructor(source: string) {\n this.source = source;\n }\n\n tokenize(): { tokens: Token[]; errors: LexerError[] } {\n while (!this.isAtEnd()) {\n this.start = this.current;\n this.scanToken();\n }\n this.tokens.push({\n type: TokenType.EOF,\n value: null,\n lexeme: \"\",\n line: this.line,\n column: this.column,\n offset: this.current,\n });\n return { tokens: this.tokens, errors: this.errors };\n }\n\n private isAtEnd(): boolean {\n return this.current >= this.source.length;\n }\n\n private advance(): string {\n const c = this.source[this.current++];\n this.column++;\n return c;\n }\n\n private peek(): string {\n return this.isAtEnd() ? \"\\0\" : this.source[this.current];\n }\n\n private peekNext(): string {\n return this.current + 1 >= this.source.length ? \"\\0\" : this.source[this.current + 1];\n }\n\n private peekAt(offset: number): string {\n const pos = this.current + offset;\n return pos >= this.source.length ? \"\\0\" : this.source[pos];\n }\n\n private match(expected: string): boolean {\n if (this.isAtEnd() || this.source[this.current] !== expected) return false;\n this.current++;\n this.column++;\n return true;\n }\n\n private addToken(type: TokenType, value: string | number | boolean | null = null): void {\n const lexeme = this.source.slice(this.start, this.current);\n this.tokens.push({\n type,\n value: value ?? lexeme,\n lexeme,\n line: this.line,\n column: this.column - lexeme.length,\n offset: this.start,\n });\n }\n\n private error(message: string): void {\n this.errors.push({\n message,\n line: this.line,\n column: this.column,\n offset: this.current,\n });\n }\n\n private scanToken(): void {\n const c = this.advance();\n\n switch (c) {\n // Single-character tokens\n case \"(\": this.addToken(TokenType.LPAREN); break;\n case \")\": this.addToken(TokenType.RPAREN); break;\n case \"{\": this.addToken(TokenType.LBRACE); break;\n case \"}\": this.addToken(TokenType.RBRACE); break;\n case \"[\": this.addToken(TokenType.LBRACKET); break;\n case \"]\": this.addToken(TokenType.RBRACKET); break;\n case \",\": this.addToken(TokenType.COMMA); break;\n case \".\": this.addToken(TokenType.DOT); break;\n case \";\": this.addToken(TokenType.SEMICOLON); break;\n case \"~\": this.addToken(TokenType.TILDE); break;\n case \"?\": this.addToken(TokenType.QUESTION); break;\n\n // One or two character tokens\n case \"+\":\n if (this.match(\"+\")) this.addToken(TokenType.PLUS_PLUS);\n else if (this.match(\"=\")) this.addToken(TokenType.PLUS_EQUAL);\n else this.addToken(TokenType.PLUS);\n break;\n case \"-\":\n if (this.match(\"-\")) this.addToken(TokenType.MINUS_MINUS);\n else if (this.match(\"=\")) this.addToken(TokenType.MINUS_EQUAL);\n else if (this.match(\">\")) this.addToken(TokenType.ARROW);\n else this.addToken(TokenType.MINUS);\n break;\n case \"*\":\n this.addToken(this.match(\"=\") ? TokenType.STAR_EQUAL : TokenType.STAR);\n break;\n case \"%\":\n this.addToken(this.match(\"=\") ? TokenType.PERCENT_EQUAL : TokenType.PERCENT);\n break;\n case \"^\":\n this.addToken(this.match(\"=\") ? TokenType.CARET_EQUAL : TokenType.CARET);\n break;\n case \"!\":\n this.addToken(this.match(\"=\") ? TokenType.BANG_EQUAL : TokenType.BANG);\n break;\n case \"=\":\n if (this.match(\"=\")) this.addToken(TokenType.EQUAL_EQUAL);\n else if (this.match(\">\")) this.addToken(TokenType.FAT_ARROW);\n else this.addToken(TokenType.EQUAL);\n break;\n case \"<\":\n if (this.match(\"<\")) {\n this.addToken(this.match(\"=\") ? TokenType.LESS_LESS_EQUAL : TokenType.LESS_LESS);\n } else if (this.match(\"=\")) {\n this.addToken(TokenType.LESS_EQUAL);\n } else {\n this.addToken(TokenType.LESS);\n }\n break;\n case \">\":\n if (this.match(\">\")) {\n if (this.match(\">\")) {\n this.addToken(TokenType.GREATER_GREATER_GREATER);\n } else if (this.match(\"=\")) {\n this.addToken(TokenType.GREATER_GREATER_EQUAL);\n } else {\n this.addToken(TokenType.GREATER_GREATER);\n }\n } else if (this.match(\"=\")) {\n this.addToken(TokenType.GREATER_EQUAL);\n } else {\n this.addToken(TokenType.GREATER);\n }\n break;\n case \"&\":\n if (this.match(\"&\")) this.addToken(TokenType.AMPERSAND_AMPERSAND);\n else if (this.match(\"=\")) this.addToken(TokenType.AMPERSAND_EQUAL);\n else this.addToken(TokenType.AMPERSAND);\n break;\n case \"|\":\n if (this.match(\"|\")) this.addToken(TokenType.PIPE_PIPE);\n else if (this.match(\"=\")) this.addToken(TokenType.PIPE_EQUAL);\n else this.addToken(TokenType.PIPE);\n break;\n case \":\":\n this.addToken(this.match(\":\") ? TokenType.DOUBLE_COLON : TokenType.COLON);\n break;\n\n // Slash - could be division or comment\n case \"/\":\n if (this.match(\"/\")) {\n // Single-line comment\n while (this.peek() !== \"\\n\" && !this.isAtEnd()) this.advance();\n } else if (this.match(\"*\")) {\n // Multi-line comment\n this.blockComment();\n } else if (this.match(\"=\")) {\n this.addToken(TokenType.SLASH_EQUAL);\n } else {\n this.addToken(TokenType.SLASH);\n }\n break;\n\n // Hash comments (Python, Ruby, etc.)\n case \"#\":\n while (this.peek() !== \"\\n\" && !this.isAtEnd()) this.advance();\n break;\n\n // Whitespace\n case \" \":\n case \"\\r\":\n case \"\\t\":\n break;\n case \"\\n\":\n this.line++;\n this.column = 1;\n this.lineStart = this.current;\n break;\n\n // Strings\n case '\"': this.string('\"'); break;\n case \"'\": this.string(\"'\"); break;\n case \"`\": this.templateString(); break;\n\n default:\n if (this.isDigit(c)) {\n this.number();\n } else if (this.isAlpha(c)) {\n this.identifier();\n } else {\n this.error(`Unexpected character: '${c}'`);\n }\n }\n }\n\n private blockComment(): void {\n let depth = 1;\n while (depth > 0 && !this.isAtEnd()) {\n if (this.peek() === \"/\" && this.peekNext() === \"*\") {\n this.advance();\n this.advance();\n depth++;\n } else if (this.peek() === \"*\" && this.peekNext() === \"/\") {\n this.advance();\n this.advance();\n depth--;\n } else {\n if (this.peek() === \"\\n\") {\n this.line++;\n this.column = 0;\n }\n this.advance();\n }\n }\n }\n\n private string(quote: string): void {\n let value = \"\";\n while (this.peek() !== quote && !this.isAtEnd()) {\n if (this.peek() === \"\\n\") {\n this.line++;\n this.column = 0;\n }\n if (this.peek() === \"\\\\\") {\n this.advance();\n const escaped = this.advance();\n switch (escaped) {\n case \"n\": value += \"\\n\"; break;\n case \"r\": value += \"\\r\"; break;\n case \"t\": value += \"\\t\"; break;\n case \"0\": value += \"\\0\"; break;\n case \"\\\\\": value += \"\\\\\"; break;\n case '\"': value += '\"'; break;\n case \"'\": value += \"'\"; break;\n case \"x\":\n const hex = this.source.slice(this.current, this.current + 2);\n this.current += 2;\n this.column += 2;\n value += String.fromCharCode(parseInt(hex, 16));\n break;\n case \"u\":\n if (this.peek() === \"{\") {\n this.advance();\n let unicode = \"\";\n while (this.peek() !== \"}\" && !this.isAtEnd()) {\n unicode += this.advance();\n }\n this.advance();\n value += String.fromCodePoint(parseInt(unicode, 16));\n } else {\n const uni = this.source.slice(this.current, this.current + 4);\n this.current += 4;\n this.column += 4;\n value += String.fromCharCode(parseInt(uni, 16));\n }\n break;\n default:\n value += escaped;\n }\n } else {\n value += this.advance();\n }\n }\n\n if (this.isAtEnd()) {\n this.error(\"Unterminated string\");\n return;\n }\n\n this.advance(); // Closing quote\n this.addToken(TokenType.STRING, value);\n }\n\n private templateString(): void {\n let value = \"\";\n while (this.peek() !== \"`\" && !this.isAtEnd()) {\n if (this.peek() === \"\\n\") {\n this.line++;\n this.column = 0;\n }\n if (this.peek() === \"$\" && this.peekNext() === \"{\") {\n // For now, treat template expressions as plain text\n // A full implementation would handle nested tokenization\n }\n value += this.advance();\n }\n\n if (this.isAtEnd()) {\n this.error(\"Unterminated template string\");\n return;\n }\n\n this.advance();\n this.addToken(TokenType.STRING, value);\n }\n\n private number(): void {\n // Check for different bases\n if (this.source[this.start] === \"0\") {\n const next = this.peek().toLowerCase();\n if (next === \"x\") {\n this.advance();\n this.hexNumber();\n return;\n } else if (next === \"b\") {\n this.advance();\n this.binaryNumber();\n return;\n } else if (next === \"o\") {\n this.advance();\n this.octalNumber();\n return;\n }\n }\n\n // Decimal number\n while (this.isDigit(this.peek()) || this.peek() === \"_\") {\n if (this.peek() === \"_\") {\n this.advance();\n continue;\n }\n this.advance();\n }\n\n // Float part\n let isFloat = false;\n if (this.peek() === \".\" && this.isDigit(this.peekNext())) {\n isFloat = true;\n this.advance();\n while (this.isDigit(this.peek()) || this.peek() === \"_\") {\n if (this.peek() === \"_\") {\n this.advance();\n continue;\n }\n this.advance();\n }\n }\n\n // Exponent\n if (this.peek().toLowerCase() === \"e\") {\n isFloat = true;\n this.advance();\n if (this.peek() === \"+\" || this.peek() === \"-\") this.advance();\n while (this.isDigit(this.peek())) this.advance();\n }\n\n // Type suffix\n const suffixStart = this.current;\n while (this.isAlpha(this.peek()) || this.isDigit(this.peek())) {\n this.advance();\n }\n const suffix = this.source.slice(suffixStart, this.current).toLowerCase();\n\n let numStr = this.source.slice(this.start, suffixStart).replace(/_/g, \"\");\n let value: number;\n\n if (isFloat || [\"f32\", \"f64\", \"f\", \"d\"].includes(suffix)) {\n value = parseFloat(numStr);\n this.addToken(TokenType.FLOAT, value);\n } else {\n value = parseInt(numStr, 10);\n this.addToken(TokenType.INTEGER, value);\n }\n }\n\n private hexNumber(): void {\n const start = this.current;\n while (this.isHexDigit(this.peek()) || this.peek() === \"_\") {\n if (this.peek() === \"_\") {\n this.advance();\n continue;\n }\n this.advance();\n }\n const numStr = this.source.slice(start, this.current).replace(/_/g, \"\");\n this.addToken(TokenType.INTEGER, parseInt(numStr, 16));\n }\n\n private binaryNumber(): void {\n const start = this.current;\n while (this.peek() === \"0\" || this.peek() === \"1\" || this.peek() === \"_\") {\n if (this.peek() === \"_\") {\n this.advance();\n continue;\n }\n this.advance();\n }\n const numStr = this.source.slice(start, this.current).replace(/_/g, \"\");\n this.addToken(TokenType.INTEGER, parseInt(numStr, 2));\n }\n\n private octalNumber(): void {\n const start = this.current;\n while (this.peek() >= \"0\" && this.peek() <= \"7\" || this.peek() === \"_\") {\n if (this.peek() === \"_\") {\n this.advance();\n continue;\n }\n this.advance();\n }\n const numStr = this.source.slice(start, this.current).replace(/_/g, \"\");\n this.addToken(TokenType.INTEGER, parseInt(numStr, 8));\n }\n\n private identifier(): void {\n while (this.isAlphaNumeric(this.peek())) this.advance();\n\n const text = this.source.slice(this.start, this.current);\n \n // Check for boolean literals\n if (text === \"true\") {\n this.addToken(TokenType.BOOLEAN, true);\n } else if (text === \"false\") {\n this.addToken(TokenType.BOOLEAN, false);\n } else if (KEYWORDS.has(text)) {\n this.addToken(TokenType.KEYWORD, text);\n } else {\n this.addToken(TokenType.IDENTIFIER, text);\n }\n }\n\n private isDigit(c: string): boolean {\n return c >= \"0\" && c <= \"9\";\n }\n\n private isHexDigit(c: string): boolean {\n return (c >= \"0\" && c <= \"9\") || (c >= \"a\" && c <= \"f\") || (c >= \"A\" && c <= \"F\");\n }\n\n private isAlpha(c: string): boolean {\n return (c >= \"a\" && c <= \"z\") || (c >= \"A\" && c <= \"Z\") || c === \"_\" || c === \"$\";\n }\n\n private isAlphaNumeric(c: string): boolean {\n return this.isAlpha(c) || this.isDigit(c);\n }\n}\n\n// ============================================================================\n// SECTION 3: ABSTRACT SYNTAX TREE\n// ============================================================================\n\nexport interface SourceLocation {\n line: number;\n column: number;\n offset: number;\n length: number;\n}\n\n// Base AST Node\nexport interface ASTNode {\n kind: string;\n loc?: SourceLocation;\n}\n\n// Expressions\nexport interface IntegerLiteral extends ASTNode {\n kind: \"IntegerLiteral\";\n value: bigint;\n type: WasmType;\n}\n\nexport interface FloatLiteral extends ASTNode {\n kind: \"FloatLiteral\";\n value: number;\n type: WasmType;\n}\n\nexport interface BooleanLiteral extends ASTNode {\n kind: \"BooleanLiteral\";\n value: boolean;\n}\n\nexport interface StringLiteral extends ASTNode {\n kind: \"StringLiteral\";\n value: string;\n}\n\nexport interface NullLiteral extends ASTNode {\n kind: \"NullLiteral\";\n}\n\nexport interface Identifier extends ASTNode {\n kind: \"Identifier\";\n name: string;\n}\n\nexport interface BinaryExpression extends ASTNode {\n kind: \"BinaryExpression\";\n operator: string;\n left: Expression;\n right: Expression;\n}\n\nexport interface UnaryExpression extends ASTNode {\n kind: \"UnaryExpression\";\n operator: string;\n operand: Expression;\n prefix: boolean;\n}\n\nexport interface CallExpression extends ASTNode {\n kind: \"CallExpression\";\n callee: Expression;\n arguments: Expression[];\n}\n\nexport interface MemberExpression extends ASTNode {\n kind: \"MemberExpression\";\n object: Expression;\n property: Expression;\n computed: boolean;\n}\n\nexport interface IndexExpression extends ASTNode {\n kind: \"IndexExpression\";\n object: Expression;\n index: Expression;\n}\n\nexport interface AssignmentExpression extends ASTNode {\n kind: \"AssignmentExpression\";\n operator: string;\n left: Expression;\n right: Expression;\n}\n\nexport interface ConditionalExpression extends ASTNode {\n kind: \"ConditionalExpression\";\n condition: Expression;\n consequent: Expression;\n alternate: Expression;\n}\n\nexport interface ArrayExpression extends ASTNode {\n kind: \"ArrayExpression\";\n elements: Expression[];\n}\n\nexport interface ObjectExpression extends ASTNode {\n kind: \"ObjectExpression\";\n properties: { key: string; value: Expression }[];\n}\n\nexport interface CastExpression extends ASTNode {\n kind: \"CastExpression\";\n expression: Expression;\n targetType: TypeAnnotation;\n}\n\nexport interface GroupExpression extends ASTNode {\n kind: \"GroupExpression\";\n expression: Expression;\n}\n\nexport interface LambdaExpression extends ASTNode {\n kind: \"LambdaExpression\";\n params: Parameter[];\n returnType?: TypeAnnotation;\n body: Expression | BlockStatement;\n}\n\nexport type Expression =\n | IntegerLiteral\n | FloatLiteral\n | BooleanLiteral\n | StringLiteral\n | NullLiteral\n | Identifier\n | BinaryExpression\n | UnaryExpression\n | CallExpression\n | MemberExpression\n | IndexExpression\n | AssignmentExpression\n | ConditionalExpression\n | ArrayExpression\n | ObjectExpression\n | CastExpression\n | GroupExpression\n | LambdaExpression;\n\n// Type Annotations\nexport interface PrimitiveType extends ASTNode {\n kind: \"PrimitiveType\";\n name: string;\n}\n\nexport interface ArrayType extends ASTNode {\n kind: \"ArrayType\";\n elementType: TypeAnnotation;\n size?: number;\n}\n\nexport interface FunctionTypeNode extends ASTNode {\n kind: \"FunctionType\";\n params: TypeAnnotation[];\n returnType: TypeAnnotation;\n}\n\nexport interface GenericType extends ASTNode {\n kind: \"GenericType\";\n name: string;\n typeArgs: TypeAnnotation[];\n}\n\nexport interface UnionType extends ASTNode {\n kind: \"UnionType\";\n types: TypeAnnotation[];\n}\n\nexport interface IntersectionType extends ASTNode {\n kind: \"IntersectionType\";\n types: TypeAnnotation[];\n}\n\nexport interface TupleType extends ASTNode {\n kind: \"TupleType\";\n elements: TypeAnnotation[];\n}\n\nexport interface PointerType extends ASTNode {\n kind: \"PointerType\";\n pointeeType: TypeAnnotation;\n mutable: boolean;\n}\n\nexport interface ReferenceType extends ASTNode {\n kind: \"ReferenceType\";\n referentType: TypeAnnotation;\n mutable: boolean;\n}\n\nexport interface OptionalType extends ASTNode {\n kind: \"OptionalType\";\n innerType: TypeAnnotation;\n}\n\nexport type TypeAnnotation =\n | PrimitiveType\n | ArrayType\n | FunctionTypeNode\n | GenericType\n | UnionType\n | IntersectionType\n | TupleType\n | PointerType\n | ReferenceType\n | OptionalType;\n\n// Statements\nexport interface ExpressionStatement extends ASTNode {\n kind: \"ExpressionStatement\";\n expression: Expression;\n}\n\nexport interface BlockStatement extends ASTNode {\n kind: \"BlockStatement\";\n body: Statement[];\n}\n\nexport interface VariableDeclaration extends ASTNode {\n kind: \"VariableDeclaration\";\n declarationType: \"let\" | \"const\" | \"var\" | \"mut\";\n name: string;\n type?: TypeAnnotation;\n init?: Expression;\n}\n\nexport interface FunctionDeclaration extends ASTNode {\n kind: \"FunctionDeclaration\";\n name: string;\n params: Parameter[];\n returnType?: TypeAnnotation;\n body: BlockStatement;\n exported: boolean;\n async: boolean;\n generator: boolean;\n decorators: Decorator[];\n generic?: GenericParams;\n}\n\nexport interface Parameter extends ASTNode {\n kind: \"Parameter\";\n name: string;\n type?: TypeAnnotation;\n defaultValue?: Expression;\n rest: boolean;\n mutable: boolean;\n}\n\nexport interface ReturnStatement extends ASTNode {\n kind: \"ReturnStatement\";\n value?: Expression;\n}\n\nexport interface IfStatement extends ASTNode {\n kind: \"IfStatement\";\n condition: Expression;\n consequent: Statement;\n alternate?: Statement;\n}\n\nexport interface WhileStatement extends ASTNode {\n kind: \"WhileStatement\";\n condition: Expression;\n body: Statement;\n doWhile: boolean;\n}\n\nexport interface ForStatement extends ASTNode {\n kind: \"ForStatement\";\n init?: VariableDeclaration | ExpressionStatement;\n condition?: Expression;\n update?: Expression;\n body: Statement;\n}\n\nexport interface ForInStatement extends ASTNode {\n kind: \"ForInStatement\";\n variable: string;\n iterable: Expression;\n body: Statement;\n}\n\nexport interface BreakStatement extends ASTNode {\n kind: \"BreakStatement\";\n label?: string;\n}\n\nexport interface ContinueStatement extends ASTNode {\n kind: \"ContinueStatement\";\n label?: string;\n}\n\nexport interface SwitchStatement extends ASTNode {\n kind: \"SwitchStatement\";\n discriminant: Expression;\n cases: SwitchCase[];\n}\n\nexport interface SwitchCase extends ASTNode {\n kind: \"SwitchCase\";\n test?: Expression;\n consequent: Statement[];\n}\n\nexport interface MatchStatement extends ASTNode {\n kind: \"MatchStatement\";\n expression: Expression;\n arms: MatchArm[];\n}\n\nexport interface MatchArm extends ASTNode {\n kind: \"MatchArm\";\n pattern: Pattern;\n guard?: Expression;\n body: Expression | BlockStatement;\n}\n\nexport interface Pattern extends ASTNode {\n kind: \"Pattern\";\n type: \"literal\" | \"identifier\" | \"wildcard\" | \"tuple\" | \"struct\" | \"array\" | \"range\";\n value?: Expression | string | Pattern[];\n bindings?: { name: string; pattern?: Pattern }[];\n}\n\nexport interface TryStatement extends ASTNode {\n kind: \"TryStatement\";\n body: BlockStatement;\n handler?: CatchClause;\n finalizer?: BlockStatement;\n}\n\nexport interface CatchClause extends ASTNode {\n kind: \"CatchClause\";\n param?: string;\n paramType?: TypeAnnotation;\n body: BlockStatement;\n}\n\nexport interface ThrowStatement extends ASTNode {\n kind: \"ThrowStatement\";\n argument: Expression;\n}\n\nexport interface StructDeclaration extends ASTNode {\n kind: \"StructDeclaration\";\n name: string;\n fields: StructFieldDeclaration[];\n exported: boolean;\n generic?: GenericParams;\n}\n\nexport interface StructFieldDeclaration extends ASTNode {\n kind: \"StructFieldDeclaration\";\n name: string;\n type: TypeAnnotation;\n defaultValue?: Expression;\n visibility: \"public\" | \"private\" | \"protected\";\n mutable: boolean;\n}\n\nexport interface EnumDeclaration extends ASTNode {\n kind: \"EnumDeclaration\";\n name: string;\n variants: EnumVariant[];\n exported: boolean;\n}\n\nexport interface EnumVariant extends ASTNode {\n kind: \"EnumVariant\";\n name: string;\n value?: Expression;\n fields?: TypeAnnotation[];\n}\n\nexport interface TypeAliasDeclaration extends ASTNode {\n kind: \"TypeAliasDeclaration\";\n name: string;\n type: TypeAnnotation;\n exported: boolean;\n generic?: GenericParams;\n}\n\nexport interface InterfaceDeclaration extends ASTNode {\n kind: \"InterfaceDeclaration\";\n name: string;\n methods: InterfaceMethod[];\n properties: InterfaceProperty[];\n extends: string[];\n exported: boolean;\n generic?: GenericParams;\n}\n\nexport interface InterfaceMethod extends ASTNode {\n kind: \"InterfaceMethod\";\n name: string;\n params: Parameter[];\n returnType?: TypeAnnotation;\n}\n\nexport interface InterfaceProperty extends ASTNode {\n kind: \"InterfaceProperty\";\n name: string;\n type: TypeAnnotation;\n readonly: boolean;\n}\n\nexport interface ImplDeclaration extends ASTNode {\n kind: \"ImplDeclaration\";\n structName: string;\n traitName?: string;\n methods: FunctionDeclaration[];\n}\n\nexport interface ImportDeclaration extends ASTNode {\n kind: \"ImportDeclaration\";\n specifiers: ImportSpecifier[];\n source: string;\n}\n\nexport interface ImportSpecifier extends ASTNode {\n kind: \"ImportSpecifier\";\n imported: string;\n local: string;\n}\n\nexport interface ExportDeclaration extends ASTNode {\n kind: \"ExportDeclaration\";\n declaration?: Statement;\n specifiers?: ExportSpecifier[];\n source?: string;\n}\n\nexport interface ExportSpecifier extends ASTNode {\n kind: \"ExportSpecifier\";\n local: string;\n exported: string;\n}\n\nexport interface Decorator extends ASTNode {\n kind: \"Decorator\";\n name: string;\n arguments: Expression[];\n}\n\nexport interface GenericParams extends ASTNode {\n kind: \"GenericParams\";\n params: GenericParam[];\n}\n\nexport interface GenericParam extends ASTNode {\n kind: \"GenericParam\";\n name: string;\n constraint?: TypeAnnotation;\n defaultType?: TypeAnnotation;\n}\n\nexport interface MemoryDeclaration extends ASTNode {\n kind: \"MemoryDeclaration\";\n name: string;\n initial: number;\n maximum?: number;\n exported: boolean;\n}\n\nexport interface GlobalDeclaration extends ASTNode {\n kind: \"GlobalDeclaration\";\n name: string;\n type: TypeAnnotation;\n init: Expression;\n mutable: boolean;\n exported: boolean;\n}\n\nexport interface DataSegment extends ASTNode {\n kind: \"DataSegment\";\n offset: number;\n data: Uint8Array | string;\n}\n\nexport type Statement =\n | ExpressionStatement\n | BlockStatement\n | VariableDeclaration\n | FunctionDeclaration\n | ReturnStatement\n | IfStatement\n | WhileStatement\n | ForStatement\n | ForInStatement\n | BreakStatement\n | ContinueStatement\n | SwitchStatement\n | MatchStatement\n | TryStatement\n | ThrowStatement\n | StructDeclaration\n | EnumDeclaration\n | TypeAliasDeclaration\n | InterfaceDeclaration\n | ImplDeclaration\n | ImportDeclaration\n | ExportDeclaration\n | MemoryDeclaration\n | GlobalDeclaration\n | DataSegment;\n\n// Program (root node)\nexport interface Program extends ASTNode {\n kind: \"Program\";\n body: Statement[];\n}\n\n// ============================================================================\n// SECTION 4: PARSER\n// ============================================================================\n\nexport interface ParseError {\n message: string;\n token: Token;\n}\n\nexport class Parser {\n private tokens: Token[];\n private current = 0;\n private errors: ParseError[] = [];\n\n constructor(tokens: Token[]) {\n this.tokens = tokens;\n }\n\n parse(): { program: Program; errors: ParseError[] } {\n const body: Statement[] = [];\n\n while (!this.isAtEnd()) {\n try {\n const stmt = this.declaration();\n if (stmt) body.push(stmt);\n } catch (e) {\n this.synchronize();\n }\n }\n\n return {\n program: { kind: \"Program\", body },\n errors: this.errors,\n };\n }\n\n // Utilities\n private isAtEnd(): boolean {\n return this.peek().type === TokenType.EOF;\n }\n\n private peek(): Token {\n return this.tokens[this.current];\n }\n\n private peekNext(): Token {\n return this.tokens[this.current + 1] || this.tokens[this.tokens.length - 1];\n }\n\n private previous(): Token {\n return this.tokens[this.current - 1];\n }\n\n private advance(): Token {\n if (!this.isAtEnd()) this.current++;\n return this.previous();\n }\n\n private check(type: TokenType, value?: string): boolean {\n if (this.isAtEnd()) return false;\n const t = this.peek();\n if (t.type !== type) return false;\n if (value !== undefined && t.value !== value) return false;\n return true;\n }\n\n private checkKeyword(...values: string[]): boolean {\n if (this.isAtEnd()) return false;\n const t = this.peek();\n return t.type === TokenType.KEYWORD && values.includes(t.value as string);\n }\n\n private match(type: TokenType, value?: string): boolean {\n if (this.check(type, value)) {\n this.advance();\n return true;\n }\n return false;\n }\n\n private matchKeyword(...values: string[]): boolean {\n if (this.checkKeyword(...values)) {\n this.advance();\n return true;\n }\n return false;\n }\n\n private consume(type: TokenType, message: string, value?: string): Token {\n if (this.check(type, value)) return this.advance();\n throw this.error(this.peek(), message);\n }\n\n private consumeKeyword(value: string, message: string): Token {\n if (this.checkKeyword(value)) return this.advance();\n throw this.error(this.peek(), message);\n }\n\n private error(token: Token, message: string): ParseError {\n const err = { message, token };\n this.errors.push(err);\n return err;\n }\n\n private synchronize(): void {\n this.advance();\n while (!this.isAtEnd()) {\n if (this.previous().type === TokenType.SEMICOLON) return;\n if (this.checkKeyword(\"function\", \"fn\", \"func\", \"def\", \"proc\", \"let\", \"const\", \"var\",\n \"class\", \"struct\", \"interface\", \"import\", \"export\", \"if\", \"for\", \"while\",\n \"return\", \"type\", \"enum\")) {\n return;\n }\n this.advance();\n }\n }\n\n private loc(startToken: Token): SourceLocation {\n return {\n line: startToken.line,\n column: startToken.column,\n offset: startToken.offset,\n length: this.previous().offset + this.previous().lexeme.length - startToken.offset,\n };\n }\n\n // Declarations\n private declaration(): Statement | null {\n // Handle decorators\n const decorators: Decorator[] = [];\n while (this.match(TokenType.KEYWORD, \"@\") || (this.check(TokenType.IDENTIFIER) && this.peek().lexeme === \"@\")) {\n // Skip @ symbol handling - simplified\n }\n\n // Export\n if (this.matchKeyword(\"export\")) {\n return this.exportDeclaration();\n }\n\n // Import\n if (this.matchKeyword(\"import\", \"from\")) {\n return this.importDeclaration();\n }\n\n // Variable declarations\n if (this.matchKeyword(\"let\", \"const\", \"var\", \"mut\")) {\n return this.variableDeclaration(this.previous().value as string, decorators);\n }\n\n // Function declarations\n if (this.matchKeyword(\"function\", \"fn\", \"func\", \"def\", \"proc\")) {\n return this.functionDeclaration(false, decorators);\n }\n\n // Struct/Class\n if (this.matchKeyword(\"struct\", \"class\")) {\n return this.structDeclaration();\n }\n\n // Enum\n if (this.matchKeyword(\"enum\")) {\n return this.enumDeclaration();\n }\n\n // Type alias\n if (this.matchKeyword(\"type\")) {\n return this.typeAliasDeclaration();\n }\n\n // Interface/Trait\n if (this.matchKeyword(\"interface\", \"trait\")) {\n return this.interfaceDeclaration();\n }\n\n // Impl\n if (this.matchKeyword(\"impl\")) {\n return this.implDeclaration();\n }\n\n // Memory\n if (this.matchKeyword(\"memory\")) {\n return this.memoryDeclaration();\n }\n\n // Global\n if (this.matchKeyword(\"global\")) {\n return this.globalDeclaration();\n }\n\n return this.statement();\n }\n\n private exportDeclaration(): ExportDeclaration {\n const start = this.previous();\n\n // export function ...\n if (this.matchKeyword(\"function\", \"fn\", \"func\", \"def\", \"proc\")) {\n const decl = this.functionDeclaration(true, []);\n return { kind: \"ExportDeclaration\", declaration: decl, loc: this.loc(start) };\n }\n\n // export let/const ...\n if (this.matchKeyword(\"let\", \"const\", \"var\")) {\n const decl = this.variableDeclaration(this.previous().value as string, []);\n return { kind: \"ExportDeclaration\", declaration: decl, loc: this.loc(start) };\n }\n\n // export struct/class ...\n if (this.matchKeyword(\"struct\", \"class\")) {\n const decl = this.structDeclaration();\n return { kind: \"ExportDeclaration\", declaration: decl, loc: this.loc(start) };\n }\n\n // export enum ...\n if (this.matchKeyword(\"enum\")) {\n const decl = this.enumDeclaration();\n return { kind: \"ExportDeclaration\", declaration: decl, loc: this.loc(start) };\n }\n\n // export type ...\n if (this.matchKeyword(\"type\")) {\n const decl = this.typeAliasDeclaration();\n return { kind: \"ExportDeclaration\", declaration: decl, loc: this.loc(start) };\n }\n\n // export default\n if (this.matchKeyword(\"default\")) {\n const expr = this.expression();\n this.match(TokenType.SEMICOLON);\n return { kind: \"ExportDeclaration\", declaration: { kind: \"ExpressionStatement\", expression: expr }, loc: this.loc(start) };\n }\n\n // export { ... }\n if (this.check(TokenType.LBRACE)) {\n const specifiers = this.exportSpecifiers();\n this.match(TokenType.SEMICOLON);\n return { kind: \"ExportDeclaration\", specifiers, loc: this.loc(start) };\n }\n\n throw this.error(this.peek(), \"Expected declaration after 'export'\");\n }\n\n private exportSpecifiers(): ExportSpecifier[] {\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n const specifiers: ExportSpecifier[] = [];\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const local = this.consume(TokenType.IDENTIFIER, \"Expected identifier\").value as string;\n let exported = local;\n if (this.matchKeyword(\"as\")) {\n exported = this.consume(TokenType.IDENTIFIER, \"Expected identifier after 'as'\").value as string;\n }\n specifiers.push({ kind: \"ExportSpecifier\", local, exported });\n if (!this.match(TokenType.COMMA)) break;\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return specifiers;\n }\n\n private importDeclaration(): ImportDeclaration {\n const start = this.previous();\n const specifiers: ImportSpecifier[] = [];\n\n // import \"module\"\n if (this.check(TokenType.STRING)) {\n const source = this.advance().value as string;\n this.match(TokenType.SEMICOLON);\n return { kind: \"ImportDeclaration\", specifiers: [], source, loc: this.loc(start) };\n }\n\n // import { ... } from \"module\"\n if (this.check(TokenType.LBRACE)) {\n this.advance();\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const imported = this.consume(TokenType.IDENTIFIER, \"Expected identifier\").value as string;\n let local = imported;\n if (this.matchKeyword(\"as\")) {\n local = this.consume(TokenType.IDENTIFIER, \"Expected identifier after 'as'\").value as string;\n }\n specifiers.push({ kind: \"ImportSpecifier\", imported, local });\n if (!this.match(TokenType.COMMA)) break;\n }\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n }\n // import name from \"module\"\n else if (this.check(TokenType.IDENTIFIER)) {\n const name = this.advance().value as string;\n specifiers.push({ kind: \"ImportSpecifier\", imported: \"default\", local: name });\n }\n\n this.consumeKeyword(\"from\", \"Expected 'from'\");\n const source = this.consume(TokenType.STRING, \"Expected module path\").value as string;\n this.match(TokenType.SEMICOLON);\n\n return { kind: \"ImportDeclaration\", specifiers, source, loc: this.loc(start) };\n }\n\n private variableDeclaration(declType: string, _decorators: Decorator[]): VariableDeclaration {\n const start = this.previous();\n const name = this.consume(TokenType.IDENTIFIER, \"Expected variable name\").value as string;\n\n let type: TypeAnnotation | undefined;\n if (this.match(TokenType.COLON)) {\n type = this.typeAnnotation();\n }\n\n let init: Expression | undefined;\n if (this.match(TokenType.EQUAL)) {\n init = this.expression();\n }\n\n this.match(TokenType.SEMICOLON);\n\n const declarationType = declType === \"mut\" ? \"let\" : declType as \"let\" | \"const\" | \"var\";\n return { kind: \"VariableDeclaration\", declarationType, name, type, init, loc: this.loc(start) };\n }\n\n private functionDeclaration(exported: boolean, decorators: Decorator[]): FunctionDeclaration {\n const start = this.previous();\n const isAsync = this.matchKeyword(\"async\");\n const isGenerator = this.match(TokenType.STAR);\n\n const name = this.consume(TokenType.IDENTIFIER, \"Expected function name\").value as string;\n\n // Generic parameters\n let generic: GenericParams | undefined;\n if (this.match(TokenType.LESS)) {\n generic = this.genericParams();\n }\n\n // Parameters\n this.consume(TokenType.LPAREN, \"Expected '(' after function name\");\n const params = this.parameters();\n this.consume(TokenType.RPAREN, \"Expected ')' after parameters\");\n\n // Return type\n let returnType: TypeAnnotation | undefined;\n if (this.match(TokenType.COLON) || this.match(TokenType.ARROW)) {\n returnType = this.typeAnnotation();\n }\n\n // Body\n const body = this.blockStatement();\n\n return {\n kind: \"FunctionDeclaration\",\n name,\n params,\n returnType,\n body,\n exported,\n async: isAsync,\n generator: isGenerator,\n decorators,\n generic,\n loc: this.loc(start),\n };\n }\n\n private genericParams(): GenericParams {\n const params: GenericParam[] = [];\n\n do {\n const name = this.consume(TokenType.IDENTIFIER, \"Expected type parameter name\").value as string;\n let constraint: TypeAnnotation | undefined;\n let defaultType: TypeAnnotation | undefined;\n\n if (this.matchKeyword(\"extends\") || this.match(TokenType.COLON)) {\n constraint = this.typeAnnotation();\n }\n\n if (this.match(TokenType.EQUAL)) {\n defaultType = this.typeAnnotation();\n }\n\n params.push({ kind: \"GenericParam\", name, constraint, defaultType });\n } while (this.match(TokenType.COMMA));\n\n this.consume(TokenType.GREATER, \"Expected '>'\");\n return { kind: \"GenericParams\", params };\n }\n\n private parameters(): Parameter[] {\n const params: Parameter[] = [];\n\n while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {\n const isMutable = this.matchKeyword(\"mut\", \"ref\");\n const isRest = this.match(TokenType.DOT) && this.match(TokenType.DOT) && this.match(TokenType.DOT);\n\n const name = this.consume(TokenType.IDENTIFIER, \"Expected parameter name\").value as string;\n\n let type: TypeAnnotation | undefined;\n if (this.match(TokenType.COLON)) {\n type = this.typeAnnotation();\n }\n\n let defaultValue: Expression | undefined;\n if (this.match(TokenType.EQUAL)) {\n defaultValue = this.expression();\n }\n\n params.push({\n kind: \"Parameter\",\n name,\n type,\n defaultValue,\n rest: isRest,\n mutable: isMutable,\n });\n\n if (!this.match(TokenType.COMMA)) break;\n }\n\n return params;\n }\n\n private structDeclaration(): StructDeclaration {\n const start = this.previous();\n const name = this.consume(TokenType.IDENTIFIER, \"Expected struct name\").value as string;\n\n let generic: GenericParams | undefined;\n if (this.match(TokenType.LESS)) {\n generic = this.genericParams();\n }\n\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n const fields: StructFieldDeclaration[] = [];\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n let visibility: \"public\" | \"private\" | \"protected\" = \"public\";\n if (this.matchKeyword(\"public\", \"pub\")) visibility = \"public\";\n else if (this.matchKeyword(\"private\", \"priv\")) visibility = \"private\";\n else if (this.matchKeyword(\"protected\")) visibility = \"protected\";\n\n const isMutable = this.matchKeyword(\"mut\", \"var\");\n const fieldName = this.consume(TokenType.IDENTIFIER, \"Expected field name\").value as string;\n this.consume(TokenType.COLON, \"Expected ':'\");\n const fieldType = this.typeAnnotation();\n\n let defaultValue: Expression | undefined;\n if (this.match(TokenType.EQUAL)) {\n defaultValue = this.expression();\n }\n\n fields.push({\n kind: \"StructFieldDeclaration\",\n name: fieldName,\n type: fieldType,\n defaultValue,\n visibility,\n mutable: isMutable,\n });\n\n this.match(TokenType.COMMA) || this.match(TokenType.SEMICOLON);\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n\n return { kind: \"StructDeclaration\", name, fields, exported: false, generic, loc: this.loc(start) };\n }\n\n private enumDeclaration(): EnumDeclaration {\n const start = this.previous();\n const name = this.consume(TokenType.IDENTIFIER, \"Expected enum name\").value as string;\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n\n const variants: EnumVariant[] = [];\n let nextValue = 0;\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const variantName = this.consume(TokenType.IDENTIFIER, \"Expected variant name\").value as string;\n\n let value: Expression | undefined;\n let fields: TypeAnnotation[] | undefined;\n\n // Enum with value: A = 1\n if (this.match(TokenType.EQUAL)) {\n value = this.expression();\n if (value.kind === \"IntegerLiteral\") {\n nextValue = Number((value as IntegerLiteral).value) + 1;\n }\n }\n // Enum with fields: A(i32, i32)\n else if (this.check(TokenType.LPAREN)) {\n this.advance();\n fields = [];\n while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {\n fields.push(this.typeAnnotation());\n if (!this.match(TokenType.COMMA)) break;\n }\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n }\n // Implicit value\n else {\n value = { kind: \"IntegerLiteral\", value: BigInt(nextValue++), type: \"i32\" };\n }\n\n variants.push({ kind: \"EnumVariant\", name: variantName, value, fields });\n this.match(TokenType.COMMA);\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return { kind: \"EnumDeclaration\", name, variants, exported: false, loc: this.loc(start) };\n }\n\n private typeAliasDeclaration(): TypeAliasDeclaration {\n const start = this.previous();\n const name = this.consume(TokenType.IDENTIFIER, \"Expected type name\").value as string;\n\n let generic: GenericParams | undefined;\n if (this.match(TokenType.LESS)) {\n generic = this.genericParams();\n }\n\n this.consume(TokenType.EQUAL, \"Expected '='\");\n const type = this.typeAnnotation();\n this.match(TokenType.SEMICOLON);\n\n return { kind: \"TypeAliasDeclaration\", name, type, exported: false, generic, loc: this.loc(start) };\n }\n\n private interfaceDeclaration(): InterfaceDeclaration {\n const start = this.previous();\n const name = this.consume(TokenType.IDENTIFIER, \"Expected interface name\").value as string;\n\n let generic: GenericParams | undefined;\n if (this.match(TokenType.LESS)) {\n generic = this.genericParams();\n }\n\n const extendsClause: string[] = [];\n if (this.matchKeyword(\"extends\")) {\n do {\n extendsClause.push(this.consume(TokenType.IDENTIFIER, \"Expected interface name\").value as string);\n } while (this.match(TokenType.COMMA));\n }\n\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n\n const methods: InterfaceMethod[] = [];\n const properties: InterfaceProperty[] = [];\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const isReadonly = this.matchKeyword(\"readonly\");\n const memberName = this.consume(TokenType.IDENTIFIER, \"Expected member name\").value as string;\n\n // Method\n if (this.check(TokenType.LPAREN) || this.check(TokenType.LESS)) {\n this.consume(TokenType.LPAREN, \"Expected '('\");\n const params = this.parameters();\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n\n let returnType: TypeAnnotation | undefined;\n if (this.match(TokenType.COLON) || this.match(TokenType.ARROW)) {\n returnType = this.typeAnnotation();\n }\n\n methods.push({ kind: \"InterfaceMethod\", name: memberName, params, returnType });\n }\n // Property\n else {\n this.consume(TokenType.COLON, \"Expected ':'\");\n const propType = this.typeAnnotation();\n properties.push({ kind: \"InterfaceProperty\", name: memberName, type: propType, readonly: isReadonly });\n }\n\n this.match(TokenType.COMMA) || this.match(TokenType.SEMICOLON);\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n\n return {\n kind: \"InterfaceDeclaration\",\n name,\n methods,\n properties,\n extends: extendsClause,\n exported: false,\n generic,\n loc: this.loc(start),\n };\n }\n\n private implDeclaration(): ImplDeclaration {\n const start = this.previous();\n\n let traitName: string | undefined;\n const firstType = this.consume(TokenType.IDENTIFIER, \"Expected type name\").value as string;\n\n // impl Trait for Struct\n if (this.matchKeyword(\"for\")) {\n traitName = firstType;\n const structName = this.consume(TokenType.IDENTIFIER, \"Expected struct name\").value as string;\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n\n const methods: FunctionDeclaration[] = [];\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n if (this.matchKeyword(\"function\", \"fn\", \"func\", \"def\")) {\n methods.push(this.functionDeclaration(false, []));\n } else {\n this.advance();\n }\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return { kind: \"ImplDeclaration\", structName, traitName, methods, loc: this.loc(start) };\n }\n\n // impl Struct\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n const methods: FunctionDeclaration[] = [];\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n if (this.matchKeyword(\"function\", \"fn\", \"func\", \"def\")) {\n methods.push(this.functionDeclaration(false, []));\n } else {\n this.advance();\n }\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return { kind: \"ImplDeclaration\", structName: firstType, methods, loc: this.loc(start) };\n }\n\n private memoryDeclaration(): MemoryDeclaration {\n const start = this.previous();\n const name = this.consume(TokenType.IDENTIFIER, \"Expected memory name\").value as string;\n this.consume(TokenType.COLON, \"Expected ':'\");\n\n let initial = 1;\n let maximum: number | undefined;\n\n if (this.check(TokenType.INTEGER)) {\n initial = this.advance().value as number;\n }\n\n if (this.match(TokenType.COMMA)) {\n if (this.check(TokenType.INTEGER)) {\n maximum = this.advance().value as number;\n }\n }\n\n this.match(TokenType.SEMICOLON);\n return { kind: \"MemoryDeclaration\", name, initial, maximum, exported: false, loc: this.loc(start) };\n }\n\n private globalDeclaration(): GlobalDeclaration {\n const start = this.previous();\n const isMutable = this.matchKeyword(\"mut\", \"var\");\n const name = this.consume(TokenType.IDENTIFIER, \"Expected global name\").value as string;\n this.consume(TokenType.COLON, \"Expected ':'\");\n const type = this.typeAnnotation();\n this.consume(TokenType.EQUAL, \"Expected '='\");\n const init = this.expression();\n this.match(TokenType.SEMICOLON);\n\n return { kind: \"GlobalDeclaration\", name, type, init, mutable: isMutable, exported: false, loc: this.loc(start) };\n }\n\n // Type annotations\n private typeAnnotation(): TypeAnnotation {\n return this.unionType();\n }\n\n private unionType(): TypeAnnotation {\n let left = this.intersectionType();\n\n while (this.match(TokenType.PIPE)) {\n const right = this.intersectionType();\n if (left.kind === \"UnionType\") {\n (left as UnionType).types.push(right);\n } else {\n left = { kind: \"UnionType\", types: [left, right] };\n }\n }\n\n return left;\n }\n\n private intersectionType(): TypeAnnotation {\n let left = this.primaryType();\n\n while (this.match(TokenType.AMPERSAND)) {\n const right = this.primaryType();\n if (left.kind === \"IntersectionType\") {\n (left as IntersectionType).types.push(right);\n } else {\n left = { kind: \"IntersectionType\", types: [left, right] };\n }\n }\n\n return left;\n }\n\n private primaryType(): TypeAnnotation {\n // Pointer type: *T or &T\n if (this.match(TokenType.STAR)) {\n const pointee = this.primaryType();\n return { kind: \"PointerType\", pointeeType: pointee, mutable: true };\n }\n\n if (this.match(TokenType.AMPERSAND)) {\n const isMut = this.matchKeyword(\"mut\");\n const referent = this.primaryType();\n return { kind: \"ReferenceType\", referentType: referent, mutable: isMut };\n }\n\n // Tuple type: (T1, T2, ...)\n if (this.check(TokenType.LPAREN)) {\n this.advance();\n if (this.check(TokenType.RPAREN)) {\n this.advance();\n return { kind: \"PrimitiveType\", name: \"void\" };\n }\n\n const types: TypeAnnotation[] = [];\n do {\n types.push(this.typeAnnotation());\n } while (this.match(TokenType.COMMA));\n\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n\n if (types.length === 1) return types[0];\n return { kind: \"TupleType\", elements: types };\n }\n\n // Array type: [T; N] or T[]\n if (this.check(TokenType.LBRACKET)) {\n this.advance();\n const elemType = this.typeAnnotation();\n let size: number | undefined;\n\n if (this.match(TokenType.SEMICOLON)) {\n size = this.consume(TokenType.INTEGER, \"Expected array size\").value as number;\n }\n\n this.consume(TokenType.RBRACKET, \"Expected ']'\");\n return { kind: \"ArrayType\", elementType: elemType, size };\n }\n\n // Function type: fn(T1, T2) -> R\n if (this.matchKeyword(\"fn\", \"func\", \"function\")) {\n this.consume(TokenType.LPAREN, \"Expected '('\");\n const params: TypeAnnotation[] = [];\n\n while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {\n params.push(this.typeAnnotation());\n if (!this.match(TokenType.COMMA)) break;\n }\n\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n this.consume(TokenType.ARROW, \"Expected '->'\");\n const returnType = this.typeAnnotation();\n\n return { kind: \"FunctionType\", params, returnType };\n }\n\n // Named type (possibly generic)\n if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.KEYWORD)) {\n const name = this.advance().value as string;\n\n // Optional type: T?\n if (this.match(TokenType.QUESTION)) {\n return { kind: \"OptionalType\", innerType: { kind: \"PrimitiveType\", name } };\n }\n\n // Generic type: T\n if (this.match(TokenType.LESS)) {\n const typeArgs: TypeAnnotation[] = [];\n do {\n typeArgs.push(this.typeAnnotation());\n } while (this.match(TokenType.COMMA));\n this.consume(TokenType.GREATER, \"Expected '>'\");\n return { kind: \"GenericType\", name, typeArgs };\n }\n\n // Array shorthand: T[]\n if (this.match(TokenType.LBRACKET)) {\n this.consume(TokenType.RBRACKET, \"Expected ']'\");\n return { kind: \"ArrayType\", elementType: { kind: \"PrimitiveType\", name } };\n }\n\n return { kind: \"PrimitiveType\", name };\n }\n\n throw this.error(this.peek(), \"Expected type annotation\");\n }\n\n // Statements\n private statement(): Statement {\n if (this.matchKeyword(\"if\")) return this.ifStatement();\n if (this.matchKeyword(\"while\")) return this.whileStatement();\n if (this.matchKeyword(\"do\")) return this.doWhileStatement();\n if (this.matchKeyword(\"for\")) return this.forStatement();\n if (this.matchKeyword(\"loop\")) return this.loopStatement();\n if (this.matchKeyword(\"switch\")) return this.switchStatement();\n if (this.matchKeyword(\"match\")) return this.matchStatement();\n if (this.matchKeyword(\"return\")) return this.returnStatement();\n if (this.matchKeyword(\"break\")) return this.breakStatement();\n if (this.matchKeyword(\"continue\")) return this.continueStatement();\n if (this.matchKeyword(\"throw\", \"raise\", \"panic\")) return this.throwStatement();\n if (this.matchKeyword(\"try\")) return this.tryStatement();\n if (this.check(TokenType.LBRACE)) return this.blockStatement();\n\n return this.expressionStatement();\n }\n\n private blockStatement(): BlockStatement {\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n const body: Statement[] = [];\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const decl = this.declaration();\n if (decl) body.push(decl);\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return { kind: \"BlockStatement\", body };\n }\n\n private ifStatement(): IfStatement {\n const start = this.previous();\n\n // Optional parentheses around condition\n const hasParen = this.match(TokenType.LPAREN);\n const condition = this.expression();\n if (hasParen) this.consume(TokenType.RPAREN, \"Expected ')'\");\n\n this.matchKeyword(\"then\"); // Optional 'then' keyword\n\n const consequent = this.check(TokenType.LBRACE) ? this.blockStatement() : this.statement();\n\n let alternate: Statement | undefined;\n if (this.matchKeyword(\"else\", \"elif\", \"elseif\")) {\n if (this.previous().value === \"elif\" || this.previous().value === \"elseif\") {\n alternate = this.ifStatement();\n } else {\n alternate = this.check(TokenType.LBRACE) ? this.blockStatement() : this.statement();\n }\n }\n\n return { kind: \"IfStatement\", condition, consequent, alternate, loc: this.loc(start) };\n }\n\n private whileStatement(): WhileStatement {\n const start = this.previous();\n const hasParen = this.match(TokenType.LPAREN);\n const condition = this.expression();\n if (hasParen) this.consume(TokenType.RPAREN, \"Expected ')'\");\n\n const body = this.check(TokenType.LBRACE) ? this.blockStatement() : this.statement();\n\n return { kind: \"WhileStatement\", condition, body, doWhile: false, loc: this.loc(start) };\n }\n\n private doWhileStatement(): WhileStatement {\n const start = this.previous();\n const body = this.blockStatement();\n\n this.consumeKeyword(\"while\", \"Expected 'while'\");\n const hasParen = this.match(TokenType.LPAREN);\n const condition = this.expression();\n if (hasParen) this.consume(TokenType.RPAREN, \"Expected ')'\");\n this.match(TokenType.SEMICOLON);\n\n return { kind: \"WhileStatement\", condition, body, doWhile: true, loc: this.loc(start) };\n }\n\n private forStatement(): ForStatement | ForInStatement {\n const start = this.previous();\n this.consume(TokenType.LPAREN, \"Expected '('\");\n\n // for (x in iterable) or for (x of iterable)\n if (this.check(TokenType.IDENTIFIER) && (this.peekNext().type === TokenType.KEYWORD && \n (this.peekNext().value === \"in\" || this.peekNext().value === \"of\"))) {\n const variable = this.advance().value as string;\n this.advance(); // consume 'in' or 'of'\n const iterable = this.expression();\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n const body = this.check(TokenType.LBRACE) ? this.blockStatement() : this.statement();\n return { kind: \"ForInStatement\", variable, iterable, body, loc: this.loc(start) };\n }\n\n // C-style for loop\n let init: VariableDeclaration | ExpressionStatement | undefined;\n if (!this.check(TokenType.SEMICOLON)) {\n if (this.matchKeyword(\"let\", \"const\", \"var\")) {\n init = this.variableDeclaration(this.previous().value as string, []);\n } else {\n init = this.expressionStatement();\n }\n } else {\n this.advance();\n }\n\n let condition: Expression | undefined;\n if (!this.check(TokenType.SEMICOLON)) {\n condition = this.expression();\n }\n this.consume(TokenType.SEMICOLON, \"Expected ';'\");\n\n let update: Expression | undefined;\n if (!this.check(TokenType.RPAREN)) {\n update = this.expression();\n }\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n\n const body = this.check(TokenType.LBRACE) ? this.blockStatement() : this.statement();\n\n return { kind: \"ForStatement\", init, condition, update, body, loc: this.loc(start) };\n }\n\n private loopStatement(): WhileStatement {\n const start = this.previous();\n const body = this.blockStatement();\n\n return {\n kind: \"WhileStatement\",\n condition: { kind: \"BooleanLiteral\", value: true },\n body,\n doWhile: false,\n loc: this.loc(start),\n };\n }\n\n private switchStatement(): SwitchStatement {\n const start = this.previous();\n this.consume(TokenType.LPAREN, \"Expected '('\");\n const discriminant = this.expression();\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n\n const cases: SwitchCase[] = [];\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n if (this.matchKeyword(\"case\")) {\n const test = this.expression();\n this.consume(TokenType.COLON, \"Expected ':'\");\n\n const consequent: Statement[] = [];\n while (!this.checkKeyword(\"case\", \"default\") && !this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const stmt = this.statement();\n if (stmt) consequent.push(stmt);\n }\n\n cases.push({ kind: \"SwitchCase\", test, consequent });\n } else if (this.matchKeyword(\"default\")) {\n this.consume(TokenType.COLON, \"Expected ':'\");\n\n const consequent: Statement[] = [];\n while (!this.checkKeyword(\"case\") && !this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const stmt = this.statement();\n if (stmt) consequent.push(stmt);\n }\n\n cases.push({ kind: \"SwitchCase\", consequent });\n } else {\n this.advance();\n }\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return { kind: \"SwitchStatement\", discriminant, cases, loc: this.loc(start) };\n }\n\n private matchStatement(): MatchStatement {\n const start = this.previous();\n const expression = this.expression();\n this.consume(TokenType.LBRACE, \"Expected '{'\");\n\n const arms: MatchArm[] = [];\n\n while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n const pattern = this.pattern();\n\n let guard: Expression | undefined;\n if (this.matchKeyword(\"if\", \"when\")) {\n guard = this.expression();\n }\n\n this.consume(TokenType.FAT_ARROW, \"Expected '=>'\");\n\n let body: Expression | BlockStatement;\n if (this.check(TokenType.LBRACE)) {\n body = this.blockStatement();\n } else {\n body = this.expression();\n }\n\n arms.push({ kind: \"MatchArm\", pattern, guard, body });\n this.match(TokenType.COMMA);\n }\n\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return { kind: \"MatchStatement\", expression, arms, loc: this.loc(start) };\n }\n\n private pattern(): Pattern {\n // Wildcard\n if (this.check(TokenType.IDENTIFIER) && this.peek().value === \"_\") {\n this.advance();\n return { kind: \"Pattern\", type: \"wildcard\" };\n }\n\n // Tuple pattern: (a, b, c)\n if (this.check(TokenType.LPAREN)) {\n this.advance();\n const elements: Pattern[] = [];\n while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {\n elements.push(this.pattern());\n if (!this.match(TokenType.COMMA)) break;\n }\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n return { kind: \"Pattern\", type: \"tuple\", value: elements };\n }\n\n // Array pattern: [a, b, c]\n if (this.check(TokenType.LBRACKET)) {\n this.advance();\n const elements: Pattern[] = [];\n while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {\n elements.push(this.pattern());\n if (!this.match(TokenType.COMMA)) break;\n }\n this.consume(TokenType.RBRACKET, \"Expected ']'\");\n return { kind: \"Pattern\", type: \"array\", value: elements };\n }\n\n // Literal pattern\n if (this.check(TokenType.INTEGER) || this.check(TokenType.FLOAT) ||\n this.check(TokenType.STRING) || this.check(TokenType.BOOLEAN)) {\n const lit = this.primary();\n return { kind: \"Pattern\", type: \"literal\", value: lit };\n }\n\n // Identifier pattern (binds to variable)\n if (this.check(TokenType.IDENTIFIER)) {\n const name = this.advance().value as string;\n return { kind: \"Pattern\", type: \"identifier\", value: name };\n }\n\n throw this.error(this.peek(), \"Expected pattern\");\n }\n\n private returnStatement(): ReturnStatement {\n const start = this.previous();\n let value: Expression | undefined;\n\n if (!this.check(TokenType.SEMICOLON) && !this.check(TokenType.RBRACE) && !this.isAtEnd()) {\n value = this.expression();\n }\n\n this.match(TokenType.SEMICOLON);\n return { kind: \"ReturnStatement\", value, loc: this.loc(start) };\n }\n\n private breakStatement(): BreakStatement {\n const start = this.previous();\n let label: string | undefined;\n\n if (this.check(TokenType.IDENTIFIER)) {\n label = this.advance().value as string;\n }\n\n this.match(TokenType.SEMICOLON);\n return { kind: \"BreakStatement\", label, loc: this.loc(start) };\n }\n\n private continueStatement(): ContinueStatement {\n const start = this.previous();\n let label: string | undefined;\n\n if (this.check(TokenType.IDENTIFIER)) {\n label = this.advance().value as string;\n }\n\n this.match(TokenType.SEMICOLON);\n return { kind: \"ContinueStatement\", label, loc: this.loc(start) };\n }\n\n private throwStatement(): ThrowStatement {\n const start = this.previous();\n const argument = this.expression();\n this.match(TokenType.SEMICOLON);\n return { kind: \"ThrowStatement\", argument, loc: this.loc(start) };\n }\n\n private tryStatement(): TryStatement {\n const start = this.previous();\n const body = this.blockStatement();\n\n let handler: CatchClause | undefined;\n if (this.matchKeyword(\"catch\", \"except\", \"rescue\")) {\n let param: string | undefined;\n let paramType: TypeAnnotation | undefined;\n\n if (this.check(TokenType.LPAREN)) {\n this.advance();\n if (this.check(TokenType.IDENTIFIER)) {\n param = this.advance().value as string;\n if (this.match(TokenType.COLON)) {\n paramType = this.typeAnnotation();\n }\n }\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n }\n\n const catchBody = this.blockStatement();\n handler = { kind: \"CatchClause\", param, paramType, body: catchBody };\n }\n\n let finalizer: BlockStatement | undefined;\n if (this.matchKeyword(\"finally\")) {\n finalizer = this.blockStatement();\n }\n\n return { kind: \"TryStatement\", body, handler, finalizer, loc: this.loc(start) };\n }\n\n private expressionStatement(): ExpressionStatement {\n const expr = this.expression();\n this.match(TokenType.SEMICOLON);\n return { kind: \"ExpressionStatement\", expression: expr };\n }\n\n // Expressions (Pratt parser with precedence climbing)\n private expression(): Expression {\n return this.assignment();\n }\n\n private assignment(): Expression {\n const expr = this.ternary();\n\n if (this.match(TokenType.EQUAL) || this.match(TokenType.PLUS_EQUAL) ||\n this.match(TokenType.MINUS_EQUAL) || this.match(TokenType.STAR_EQUAL) ||\n this.match(TokenType.SLASH_EQUAL) || this.match(TokenType.PERCENT_EQUAL) ||\n this.match(TokenType.AMPERSAND_EQUAL) || this.match(TokenType.PIPE_EQUAL) ||\n this.match(TokenType.CARET_EQUAL) || this.match(TokenType.LESS_LESS_EQUAL) ||\n this.match(TokenType.GREATER_GREATER_EQUAL)) {\n const operator = this.previous().lexeme;\n const value = this.assignment();\n return { kind: \"AssignmentExpression\", operator, left: expr, right: value };\n }\n\n return expr;\n }\n\n private ternary(): Expression {\n let expr = this.logicalOr();\n\n if (this.match(TokenType.QUESTION)) {\n const consequent = this.expression();\n this.consume(TokenType.COLON, \"Expected ':'\");\n const alternate = this.ternary();\n return { kind: \"ConditionalExpression\", condition: expr, consequent, alternate };\n }\n\n return expr;\n }\n\n private logicalOr(): Expression {\n let left = this.logicalAnd();\n\n while (this.match(TokenType.PIPE_PIPE) || this.matchKeyword(\"or\")) {\n const operator = \"||\";\n const right = this.logicalAnd();\n left = { kind: \"BinaryExpression\", operator, left, right };\n }\n\n return left;\n }\n\n private logicalAnd(): Expression {\n let left = this.bitwiseOr();\n\n while (this.match(TokenType.AMPERSAND_AMPERSAND) || this.matchKeyword(\"and\")) {\n const operator = \"&&\";\n const right = this.bitwiseOr();\n left = { kind: \"BinaryExpression\", operator, left, right };\n }\n\n return left;\n }\n\n private bitwiseOr(): Expression {\n let left = this.bitwiseXor();\n\n while (this.match(TokenType.PIPE) && !this.check(TokenType.PIPE)) {\n const right = this.bitwiseXor();\n left = { kind: \"BinaryExpression\", operator: \"|\", left, right };\n }\n\n return left;\n }\n\n private bitwiseXor(): Expression {\n let left = this.bitwiseAnd();\n\n while (this.match(TokenType.CARET)) {\n const right = this.bitwiseAnd();\n left = { kind: \"BinaryExpression\", operator: \"^\", left, right };\n }\n\n return left;\n }\n\n private bitwiseAnd(): Expression {\n let left = this.equality();\n\n while (this.match(TokenType.AMPERSAND) && !this.check(TokenType.AMPERSAND)) {\n const right = this.equality();\n left = { kind: \"BinaryExpression\", operator: \"&\", left, right };\n }\n\n return left;\n }\n\n private equality(): Expression {\n let left = this.comparison();\n\n while (this.match(TokenType.EQUAL_EQUAL) || this.match(TokenType.BANG_EQUAL)) {\n const operator = this.previous().lexeme;\n const right = this.comparison();\n left = { kind: \"BinaryExpression\", operator, left, right };\n }\n\n return left;\n }\n\n private comparison(): Expression {\n let left = this.shift();\n\n while (this.match(TokenType.LESS) || this.match(TokenType.GREATER) ||\n this.match(TokenType.LESS_EQUAL) || this.match(TokenType.GREATER_EQUAL)) {\n const operator = this.previous().lexeme;\n const right = this.shift();\n left = { kind: \"BinaryExpression\", operator, left, right };\n }\n\n return left;\n }\n\n private shift(): Expression {\n let left = this.term();\n\n while (this.match(TokenType.LESS_LESS) || this.match(TokenType.GREATER_GREATER) ||\n this.match(TokenType.GREATER_GREATER_GREATER)) {\n const operator = this.previous().lexeme;\n const right = this.term();\n left = { kind: \"BinaryExpression\", operator, left, right };\n }\n\n return left;\n }\n\n private term(): Expression {\n let left = this.factor();\n\n while (this.match(TokenType.PLUS) || this.match(TokenType.MINUS)) {\n const operator = this.previous().lexeme;\n const right = this.factor();\n left = { kind: \"BinaryExpression\", operator, left, right };\n }\n\n return left;\n }\n\n private factor(): Expression {\n let left = this.unary();\n\n while (this.match(TokenType.STAR) || this.match(TokenType.SLASH) || this.match(TokenType.PERCENT)) {\n const operator = this.previous().lexeme;\n const right = this.unary();\n left = { kind: \"BinaryExpression\", operator, left, right };\n }\n\n return left;\n }\n\n private unary(): Expression {\n if (this.match(TokenType.BANG) || this.match(TokenType.MINUS) || this.match(TokenType.TILDE) ||\n this.matchKeyword(\"not\")) {\n const operator = this.previous().lexeme === \"not\" ? \"!\" : this.previous().lexeme;\n const operand = this.unary();\n return { kind: \"UnaryExpression\", operator, operand, prefix: true };\n }\n\n if (this.match(TokenType.PLUS_PLUS) || this.match(TokenType.MINUS_MINUS)) {\n const operator = this.previous().lexeme;\n const operand = this.unary();\n return { kind: \"UnaryExpression\", operator, operand, prefix: true };\n }\n\n return this.postfix();\n }\n\n private postfix(): Expression {\n let expr = this.call();\n\n while (true) {\n if (this.match(TokenType.PLUS_PLUS) || this.match(TokenType.MINUS_MINUS)) {\n expr = { kind: \"UnaryExpression\", operator: this.previous().lexeme, operand: expr, prefix: false };\n } else {\n break;\n }\n }\n\n return expr;\n }\n\n private call(): Expression {\n let expr = this.primary();\n\n while (true) {\n if (this.match(TokenType.LPAREN)) {\n const args: Expression[] = [];\n if (!this.check(TokenType.RPAREN)) {\n do {\n args.push(this.expression());\n } while (this.match(TokenType.COMMA));\n }\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n expr = { kind: \"CallExpression\", callee: expr, arguments: args };\n } else if (this.match(TokenType.DOT)) {\n const prop = this.consume(TokenType.IDENTIFIER, \"Expected property name\");\n expr = { kind: \"MemberExpression\", object: expr, property: { kind: \"Identifier\", name: prop.value as string }, computed: false };\n } else if (this.match(TokenType.LBRACKET)) {\n const index = this.expression();\n this.consume(TokenType.RBRACKET, \"Expected ']'\");\n expr = { kind: \"IndexExpression\", object: expr, index };\n } else if (this.matchKeyword(\"as\")) {\n const targetType = this.typeAnnotation();\n expr = { kind: \"CastExpression\", expression: expr, targetType };\n } else {\n break;\n }\n }\n\n return expr;\n }\n\n private primary(): Expression {\n // Boolean literals\n if (this.check(TokenType.BOOLEAN)) {\n const value = this.advance().value as boolean;\n return { kind: \"BooleanLiteral\", value };\n }\n\n // Null literals\n if (this.matchKeyword(\"null\", \"nil\", \"none\", \"undefined\")) {\n return { kind: \"NullLiteral\" };\n }\n\n // Integer literals\n if (this.check(TokenType.INTEGER)) {\n const value = BigInt(this.advance().value as number);\n return { kind: \"IntegerLiteral\", value, type: \"i32\" };\n }\n\n // Float literals\n if (this.check(TokenType.FLOAT)) {\n const value = this.advance().value as number;\n return { kind: \"FloatLiteral\", value, type: \"f64\" };\n }\n\n // String literals\n if (this.check(TokenType.STRING)) {\n const value = this.advance().value as string;\n return { kind: \"StringLiteral\", value };\n }\n\n // Identifiers\n if (this.check(TokenType.IDENTIFIER)) {\n const name = this.advance().value as string;\n return { kind: \"Identifier\", name };\n }\n\n // Array expressions\n if (this.match(TokenType.LBRACKET)) {\n const elements: Expression[] = [];\n if (!this.check(TokenType.RBRACKET)) {\n do {\n elements.push(this.expression());\n } while (this.match(TokenType.COMMA));\n }\n this.consume(TokenType.RBRACKET, \"Expected ']'\");\n return { kind: \"ArrayExpression\", elements };\n }\n\n // Object/struct expressions\n if (this.match(TokenType.LBRACE)) {\n const properties: { key: string; value: Expression }[] = [];\n if (!this.check(TokenType.RBRACE)) {\n do {\n const key = this.consume(TokenType.IDENTIFIER, \"Expected property name\").value as string;\n this.consume(TokenType.COLON, \"Expected ':'\");\n const value = this.expression();\n properties.push({ key, value });\n } while (this.match(TokenType.COMMA));\n }\n this.consume(TokenType.RBRACE, \"Expected '}'\");\n return { kind: \"ObjectExpression\", properties };\n }\n\n // Lambda expressions\n if (this.matchKeyword(\"fn\", \"func\", \"function\") || this.match(TokenType.PIPE)) {\n return this.lambda();\n }\n\n // Grouped expression\n if (this.match(TokenType.LPAREN)) {\n const expr = this.expression();\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n return { kind: \"GroupExpression\", expression: expr };\n }\n\n throw this.error(this.peek(), \"Expected expression\");\n }\n\n private lambda(): LambdaExpression {\n const params: Parameter[] = [];\n\n // |params| syntax or (params) syntax\n if (this.previous().type === TokenType.PIPE) {\n while (!this.check(TokenType.PIPE) && !this.isAtEnd()) {\n const name = this.consume(TokenType.IDENTIFIER, \"Expected parameter name\").value as string;\n let type: TypeAnnotation | undefined;\n if (this.match(TokenType.COLON)) {\n type = this.typeAnnotation();\n }\n params.push({ kind: \"Parameter\", name, type, rest: false, mutable: false });\n if (!this.match(TokenType.COMMA)) break;\n }\n this.consume(TokenType.PIPE, \"Expected '|'\");\n } else {\n this.consume(TokenType.LPAREN, \"Expected '('\");\n while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {\n const name = this.consume(TokenType.IDENTIFIER, \"Expected parameter name\").value as string;\n let type: TypeAnnotation | undefined;\n if (this.match(TokenType.COLON)) {\n type = this.typeAnnotation();\n }\n params.push({ kind: \"Parameter\", name, type, rest: false, mutable: false });\n if (!this.match(TokenType.COMMA)) break;\n }\n this.consume(TokenType.RPAREN, \"Expected ')'\");\n }\n\n let returnType: TypeAnnotation | undefined;\n if (this.match(TokenType.COLON) || this.match(TokenType.ARROW)) {\n if (!this.check(TokenType.LBRACE) && !this.check(TokenType.FAT_ARROW)) {\n returnType = this.typeAnnotation();\n }\n }\n\n // => expr or { body }\n if (this.match(TokenType.FAT_ARROW)) {\n const body = this.expression();\n return { kind: \"LambdaExpression\", params, returnType, body };\n }\n\n const body = this.blockStatement();\n return { kind: \"LambdaExpression\", params, returnType, body };\n }\n}\n\n// ============================================================================",[],[181],{"_102":189,"_95":190,"_151":191,"_153":-5,"_154":136,"_155":192,"_156":157,"_104":193,"_99":194,"_160":195,"_162":196,"_164":22,"_165":197,"_166":198,"_98":199},"c1e09570-d1f7-11f0-a562-42dde27851f2","main.ts","dce2f25e-d1e4-11f0-96d5-42dde27851f2",32,["D",1764952248821],25,"http","// Main entry point - imports and re-exports from all modules\nimport wabtInit from \"https://esm.sh/wabt@1.0.36\";\n\nexport * from \"https://esm.town/v/ypiy/untitled-2689/compiler_types.ts\";\nexport * from \"https://esm.town/v/ypiy/untitled-2689/compiler_semantic.ts\";\nexport * from \"https://esm.town/v/ypiy/untitled-2689/compiler_server.ts\";\n\n// Re-export the main handler\nimport handleRequest from \"https://esm.town/v/ypiy/untitled-2689/compiler_server.ts\";\nexport default handleRequest;","wasmer",[],[190],"files",[148,169,179,188],"counts",{"_204":32,"_205":206,"_207":32,"_208":209},"pulls","branches",1,"forks","envVars",{"_210":32,"_211":32},"count","emptyCount","contents",[214,217,220,223],{"_102":149,"_95":150,"_151":152,"_153":-5,"_154":136,"_155":135,"_156":157,"_104":215,"_99":159,"_160":161,"_162":163,"_164":22,"_165":-5,"_98":216},["D",1764953403478],[150],{"_102":170,"_95":171,"_151":172,"_153":-5,"_154":136,"_155":173,"_156":157,"_104":218,"_99":175,"_160":161,"_162":176,"_164":22,"_165":-5,"_98":219},["D",1764952467963],[171],{"_102":180,"_95":181,"_151":182,"_153":-5,"_154":136,"_155":183,"_156":157,"_104":221,"_99":159,"_160":161,"_162":185,"_164":22,"_165":-5,"_98":222},["D",1764953292761],[181],{"_102":189,"_95":190,"_151":191,"_153":-5,"_154":136,"_155":192,"_156":157,"_104":224,"_99":194,"_160":195,"_162":196,"_164":22,"_165":197,"_98":225},["D",1764952248821],[190],"file","upstreamProject","upstreamBranch","emptyEnvVars","isNew","flags",[],"routes/_app.x.$handle.$name._index",{"_93":94,"_95":96,"_97":-7,"_99":-7,"_100":235,"_212":240,"_249":-7,"_250":-5,"_251":-5,"_200":252,"_265":266,"_267":-5,"_268":-5},{"_102":103,"_95":96,"_104":236,"_106":-5,"_107":22,"_108":109,"_110":-5,"_111":-5,"_14":112,"_113":-5,"_114":22,"_115":-5,"_116":32,"_16":117,"_118":119,"_120":119,"_121":122,"_123":122,"_124":122,"_125":119,"_126":119,"_23":237,"_130":238,"_133":239,"_145":22},["D",1764944133689],{"_93":94,"_128":129},{"_93":94,"_132":129,"_14":112},{"_99":135,"_95":43,"_102":136,"_137":103,"_138":-5,"_139":-5,"_140":-5,"_141":-5,"_142":-5,"_143":96,"_144":94},[241,243,245,247],{"_102":149,"_95":150,"_151":152,"_153":-5,"_154":136,"_155":135,"_156":157,"_104":215,"_99":159,"_160":161,"_162":163,"_164":22,"_165":-5,"_98":242},[150],{"_102":170,"_95":171,"_151":172,"_153":-5,"_154":136,"_155":173,"_156":157,"_104":218,"_99":175,"_160":161,"_162":176,"_164":22,"_165":-5,"_98":244},[171],{"_102":180,"_95":181,"_151":182,"_153":-5,"_154":136,"_155":183,"_156":157,"_104":221,"_99":159,"_160":161,"_162":185,"_164":22,"_165":-5,"_98":246},[181],{"_102":189,"_95":190,"_151":191,"_153":-5,"_154":136,"_155":192,"_156":157,"_104":224,"_99":194,"_160":195,"_162":196,"_164":22,"_165":197,"_98":248},[190],"readme","upstream","pull",[253,256,259,262],{"_102":149,"_95":150,"_151":152,"_153":-5,"_154":136,"_155":135,"_156":157,"_104":158,"_99":159,"_160":161,"_162":163,"_164":22,"_165":-5,"_166":254,"_98":255},[],[150],{"_102":170,"_95":171,"_151":172,"_153":-5,"_154":136,"_155":173,"_156":157,"_104":174,"_99":175,"_160":161,"_162":176,"_164":22,"_165":-5,"_166":257,"_98":258},[],[171],{"_102":180,"_95":181,"_151":182,"_153":-5,"_154":136,"_155":183,"_156":157,"_104":184,"_99":159,"_160":161,"_162":185,"_164":22,"_165":-5,"_166":260,"_98":261},[],[181],{"_102":189,"_95":190,"_151":191,"_153":-5,"_154":136,"_155":192,"_156":157,"_104":193,"_99":194,"_160":195,"_162":196,"_164":22,"_165":197,"_166":263,"_98":264},[],[190],"previews",[262],"ahead","behind","actionData","errors"]