@oddo/lang 0.0.1

package/dist/index.js

@@ -0,0 +1,4966 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/lexer.mjs
+var _chevrotain = require('chevrotain');
+var Identifier = _chevrotain.createToken.call(void 0, {
+  name: "Identifier",
+  pattern: /[a-zA-Z_$][a-zA-Z0-9_$]*/
+});
+var Return = _chevrotain.createToken.call(void 0, {
+  name: "Return",
+  pattern: /return\b/,
+  longer_alt: Identifier
+});
+var True = _chevrotain.createToken.call(void 0, {
+  name: "True",
+  pattern: /true\b/,
+  longer_alt: Identifier
+});
+var False = _chevrotain.createToken.call(void 0, {
+  name: "False",
+  pattern: /false\b/,
+  longer_alt: Identifier
+});
+var Null = _chevrotain.createToken.call(void 0, {
+  name: "Null",
+  pattern: /null\b/,
+  longer_alt: Identifier
+});
+var Typeof = _chevrotain.createToken.call(void 0, {
+  name: "Typeof",
+  pattern: /typeof\b/,
+  longer_alt: Identifier
+});
+var Void = _chevrotain.createToken.call(void 0, {
+  name: "Void",
+  pattern: /void\b/,
+  longer_alt: Identifier
+});
+var Delete = _chevrotain.createToken.call(void 0, {
+  name: "Delete",
+  pattern: /delete\b/,
+  longer_alt: Identifier
+});
+var Instanceof = _chevrotain.createToken.call(void 0, {
+  name: "Instanceof",
+  pattern: /instanceof\b/,
+  longer_alt: Identifier
+});
+var In = _chevrotain.createToken.call(void 0, {
+  name: "In",
+  pattern: /in\b/,
+  longer_alt: Identifier
+});
+var Export = _chevrotain.createToken.call(void 0, {
+  name: "Export",
+  pattern: /export\b/,
+  longer_alt: Identifier
+});
+var Import = _chevrotain.createToken.call(void 0, {
+  name: "Import",
+  pattern: /import\b/,
+  longer_alt: Identifier
+});
+var From = _chevrotain.createToken.call(void 0, {
+  name: "From",
+  pattern: /from\b/,
+  longer_alt: Identifier
+});
+var Default = _chevrotain.createToken.call(void 0, {
+  name: "Default",
+  pattern: /default\b/,
+  longer_alt: Identifier
+});
+var As = _chevrotain.createToken.call(void 0, {
+  name: "As",
+  pattern: /as\b/,
+  longer_alt: Identifier
+});
+var Modifier = _chevrotain.createToken.call(void 0, {
+  name: "Modifier",
+  pattern: /@[a-zA-Z_$][a-zA-Z0-9_$]*/
+});
+var NumberLiteral = _chevrotain.createToken.call(void 0, {
+  name: "NumberLiteral",
+  pattern: /-?(0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|\d+(\.\d+)?([eE][+-]?\d+)?)/
+});
+var StringLiteral = _chevrotain.createToken.call(void 0, {
+  name: "StringLiteral",
+  pattern: /"([^"\\]|\\.)*"/
+});
+var TemplateLiteral = _chevrotain.createToken.call(void 0, {
+  name: "TemplateLiteral",
+  line_breaks: true,
+  // Template literals can span multiple lines
+  pattern: (text, offset) => {
+    if (text[offset] !== "`") {
+      return null;
+    }
+    let pos = offset + 1;
+    let escaped = false;
+    let braceDepth = 0;
+    while (pos < text.length) {
+      const char = text[pos];
+      if (escaped) {
+        escaped = false;
+        pos++;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        pos++;
+        continue;
+      }
+      if (char === "`" && braceDepth === 0) {
+        return [text.substring(offset, pos + 1)];
+      }
+      if (char === "$" && pos + 1 < text.length && text[pos + 1] === "{") {
+        if (pos > offset && text[pos - 1] === "\\") {
+          pos += 2;
+          continue;
+        }
+        braceDepth++;
+        pos += 2;
+        continue;
+      }
+      if (char === "{" && braceDepth > 0) {
+        braceDepth++;
+        pos++;
+        continue;
+      }
+      if (char === "}" && braceDepth > 0) {
+        braceDepth--;
+        pos++;
+        continue;
+      }
+      pos++;
+    }
+    return null;
+  }
+});
+var PlusPlus = _chevrotain.createToken.call(void 0, { name: "PlusPlus", pattern: /\+\+/ });
+var MinusMinus = _chevrotain.createToken.call(void 0, { name: "MinusMinus", pattern: /--/ });
+var Plus = _chevrotain.createToken.call(void 0, { name: "Plus", pattern: /\+/ });
+var Minus = _chevrotain.createToken.call(void 0, { name: "Minus", pattern: /-/ });
+var StarStar = _chevrotain.createToken.call(void 0, { name: "StarStar", pattern: /\*\*/ });
+var Star = _chevrotain.createToken.call(void 0, { name: "Star", pattern: /\*/ });
+var Slash = _chevrotain.createToken.call(void 0, { name: "Slash", pattern: /\// });
+var Percent = _chevrotain.createToken.call(void 0, { name: "Percent", pattern: /%/ });
+var LessThanEqual = _chevrotain.createToken.call(void 0, { name: "LessThanEqual", pattern: /<=/ });
+var GreaterThanEqual = _chevrotain.createToken.call(void 0, { name: "GreaterThanEqual", pattern: />=/ });
+var Pipe = _chevrotain.createToken.call(void 0, { name: "Pipe", pattern: /\|>/ });
+var Compose = _chevrotain.createToken.call(void 0, { name: "Compose", pattern: /<\|/ });
+var LessThan = _chevrotain.createToken.call(void 0, { name: "LessThan", pattern: /</ });
+var GreaterThan = _chevrotain.createToken.call(void 0, { name: "GreaterThan", pattern: />/ });
+var EqualEqual = _chevrotain.createToken.call(void 0, { name: "EqualEqual", pattern: /==/ });
+var BangEqual = _chevrotain.createToken.call(void 0, { name: "BangEqual", pattern: /!=/ });
+var AndAnd = _chevrotain.createToken.call(void 0, { name: "AndAnd", pattern: /&&/ });
+var OrOr = _chevrotain.createToken.call(void 0, { name: "OrOr", pattern: /\|\|/ });
+var QuestionDot = _chevrotain.createToken.call(void 0, { name: "QuestionDot", pattern: /\?\./ });
+var QuestionQuestion = _chevrotain.createToken.call(void 0, { name: "QuestionQuestion", pattern: /\?\?/ });
+var Question = _chevrotain.createToken.call(void 0, { name: "Question", pattern: /\?/ });
+var ColonEqual = _chevrotain.createToken.call(void 0, { name: "ColonEqual", pattern: /:=/ });
+var Colon = _chevrotain.createToken.call(void 0, { name: "Colon", pattern: /:/ });
+var Bang = _chevrotain.createToken.call(void 0, { name: "Bang", pattern: /!/ });
+var Tilde = _chevrotain.createToken.call(void 0, { name: "Tilde", pattern: /~/ });
+var And = _chevrotain.createToken.call(void 0, { name: "And", pattern: /&/ });
+var Or = _chevrotain.createToken.call(void 0, { name: "Or", pattern: /\|/ });
+var Caret = _chevrotain.createToken.call(void 0, { name: "Caret", pattern: /\^/ });
+var LeftShift = _chevrotain.createToken.call(void 0, { name: "LeftShift", pattern: /<</ });
+var RightShift = _chevrotain.createToken.call(void 0, { name: "RightShift", pattern: />>/ });
+var UnsignedRightShift = _chevrotain.createToken.call(void 0, { name: "UnsignedRightShift", pattern: />>>/ });
+var PlusColonEqual = _chevrotain.createToken.call(void 0, { name: "PlusColonEqual", pattern: /\+:=/ });
+var MinusColonEqual = _chevrotain.createToken.call(void 0, { name: "MinusColonEqual", pattern: /-:=/ });
+var StarStarColonEqual = _chevrotain.createToken.call(void 0, { name: "StarStarColonEqual", pattern: /\*\*:=/ });
+var StarColonEqual = _chevrotain.createToken.call(void 0, { name: "StarColonEqual", pattern: /\*:=/ });
+var SlashColonEqual = _chevrotain.createToken.call(void 0, { name: "SlashColonEqual", pattern: /\/:=/ });
+var PercentColonEqual = _chevrotain.createToken.call(void 0, { name: "PercentColonEqual", pattern: /%:=/ });
+var LeftShiftColonEqual = _chevrotain.createToken.call(void 0, { name: "LeftShiftColonEqual", pattern: /<<:=/ });
+var RightShiftColonEqual = _chevrotain.createToken.call(void 0, { name: "RightShiftColonEqual", pattern: />>:=/ });
+var UnsignedRightShiftColonEqual = _chevrotain.createToken.call(void 0, { name: "UnsignedRightShiftColonEqual", pattern: />>>:=/ });
+var AndColonEqual = _chevrotain.createToken.call(void 0, { name: "AndColonEqual", pattern: /&:=/ });
+var CaretColonEqual = _chevrotain.createToken.call(void 0, { name: "CaretColonEqual", pattern: /\^:=/ });
+var OrColonEqual = _chevrotain.createToken.call(void 0, { name: "OrColonEqual", pattern: /\|:=/ });
+var Equal = _chevrotain.createToken.call(void 0, { name: "Equal", pattern: /=/ });
+var LeftParen = _chevrotain.createToken.call(void 0, { name: "LeftParen", pattern: /\(/ });
+var RightParen = _chevrotain.createToken.call(void 0, { name: "RightParen", pattern: /\)/ });
+var LeftBracket = _chevrotain.createToken.call(void 0, { name: "LeftBracket", pattern: /\[/ });
+var RightBracket = _chevrotain.createToken.call(void 0, { name: "RightBracket", pattern: /\]/ });
+var LeftBrace = _chevrotain.createToken.call(void 0, { name: "LeftBrace", pattern: /\{/ });
+var RightBrace = _chevrotain.createToken.call(void 0, { name: "RightBrace", pattern: /\}/ });
+var Comma = _chevrotain.createToken.call(void 0, { name: "Comma", pattern: /,/ });
+var Dot = _chevrotain.createToken.call(void 0, { name: "Dot", pattern: /\./ });
+var DotDotDot = _chevrotain.createToken.call(void 0, { name: "DotDotDot", pattern: /\.\.\./ });
+var Semicolon = _chevrotain.createToken.call(void 0, { name: "Semicolon", pattern: /;/ });
+var JSXCloseTagStart = _chevrotain.createToken.call(void 0, { name: "JSXCloseTagStart", pattern: /<\// });
+var JSXSelfClosing = _chevrotain.createToken.call(void 0, { name: "JSXSelfClosing", pattern: /\/>/ });
+var Indent = _chevrotain.createToken.call(void 0, {
+  name: "Indent",
+  pattern: /INDENT/,
+  line_breaks: false
+});
+var Dedent = _chevrotain.createToken.call(void 0, {
+  name: "Dedent",
+  pattern: /DEDENT/,
+  line_breaks: false
+});
+var WhiteSpace = _chevrotain.createToken.call(void 0, {
+  name: "WhiteSpace",
+  pattern: /\s+/,
+  group: _chevrotain.Lexer.SKIPPED
+});
+var LineComment = _chevrotain.createToken.call(void 0, {
+  name: "LineComment",
+  pattern: /\/\/.*/,
+  group: _chevrotain.Lexer.SKIPPED
+});
+var MultiLineComment = _chevrotain.createToken.call(void 0, {
+  name: "MultiLineComment",
+  pattern: /\/\*[\s\S]*?\*\//,
+  group: _chevrotain.Lexer.SKIPPED
+});
+var allTokens = [
+  WhiteSpace,
+  LineComment,
+  MultiLineComment,
+  // Keywords
+  Return,
+  True,
+  False,
+  Null,
+  Typeof,
+  Void,
+  Delete,
+  Instanceof,
+  In,
+  Export,
+  Import,
+  From,
+  Default,
+  As,
+  // Modifier
+  Modifier,
+  // Literals
+  NumberLiteral,
+  StringLiteral,
+  TemplateLiteral,
+  // Must come before Identifier to match backtick before identifiers
+  // Operators (order matters for ambiguity)
+  PlusPlus,
+  MinusMinus,
+  // Assignment operators (must come before their base operators)
+  StarStarColonEqual,
+  // **:= must come before **
+  LeftShiftColonEqual,
+  // <<:= must come before <<
+  RightShiftColonEqual,
+  // >>:= must come before >>
+  UnsignedRightShiftColonEqual,
+  // >>>:= must come before >>>
+  PlusColonEqual,
+  // +:= must come before +
+  MinusColonEqual,
+  // -:= must come before -
+  StarColonEqual,
+  // *:= must come before *
+  SlashColonEqual,
+  // /:= must come before /
+  PercentColonEqual,
+  // %:= must come before %
+  AndColonEqual,
+  // &:= must come before &
+  OrColonEqual,
+  // |:= must come before |
+  CaretColonEqual,
+  // ^:= must come before ^
+  EqualEqual,
+  BangEqual,
+  LessThanEqual,
+  GreaterThanEqual,
+  Pipe,
+  // Must come before GreaterThan to match |> before >
+  Compose,
+  // Must come before LessThan to match <| before <
+  LeftShift,
+  UnsignedRightShift,
+  // Must come before RightShift (>>> before >>)
+  RightShift,
+  StarStar,
+  AndAnd,
+  OrOr,
+  Equal,
+  Plus,
+  Minus,
+  Star,
+  Percent,
+  // JSX tokens must come before LessThan/GreaterThan/Slash to avoid conflicts
+  JSXCloseTagStart,
+  // </ must come before <
+  JSXSelfClosing,
+  // /> must come before /
+  LessThan,
+  GreaterThan,
+  // Slash must come after JSXSelfClosing to avoid conflicts
+  Slash,
+  And,
+  Or,
+  Caret,
+  Bang,
+  Tilde,
+  QuestionDot,
+  // Must come before Question to match ?. before ?
+  QuestionQuestion,
+  Question,
+  ColonEqual,
+  // Must come before Colon to match := before :
+  Colon,
+  // Punctuation
+  LeftParen,
+  RightParen,
+  LeftBracket,
+  RightBracket,
+  LeftBrace,
+  RightBrace,
+  Comma,
+  DotDotDot,
+  // Must come before Dot to match ... before .
+  Dot,
+  Semicolon,
+  // Note: JSXOpenTag and JSXCloseTag use < and > tokens
+  // Identifiers (must be last)
+  Identifier
+];
+var lexer = new (0, _chevrotain.Lexer)(allTokens);
+
+// src/parser.mjs
+
+var MAX_TOKEN_LOOKAHEAD_COUNT = 30;
+var OddoParser = class extends _chevrotain.CstParser {
+  constructor() {
+    super([
+      // Keywords
+      Return,
+      True,
+      False,
+      Null,
+      Typeof,
+      Void,
+      Delete,
+      Instanceof,
+      In,
+      Export,
+      Import,
+      From,
+      Default,
+      As,
+      // Literals
+      NumberLiteral,
+      StringLiteral,
+      Identifier,
+      Modifier,
+      // Operators
+      PlusPlus,
+      MinusMinus,
+      Plus,
+      Minus,
+      StarStar,
+      Star,
+      Slash,
+      Percent,
+      LessThanEqual,
+      GreaterThanEqual,
+      LessThan,
+      GreaterThan,
+      EqualEqual,
+      BangEqual,
+      AndAnd,
+      OrOr,
+      QuestionQuestion,
+      Question,
+      ColonEqual,
+      // Must come before Colon to match := before :
+      Colon,
+      Bang,
+      Tilde,
+      And,
+      Or,
+      Caret,
+      LeftShift,
+      RightShift,
+      UnsignedRightShift,
+      // Assignment
+      PlusColonEqual,
+      MinusColonEqual,
+      StarStarColonEqual,
+      StarColonEqual,
+      SlashColonEqual,
+      PercentColonEqual,
+      LeftShiftColonEqual,
+      RightShiftColonEqual,
+      UnsignedRightShiftColonEqual,
+      AndColonEqual,
+      CaretColonEqual,
+      OrColonEqual,
+      Equal,
+      // Punctuation
+      LeftParen,
+      RightParen,
+      LeftBracket,
+      RightBracket,
+      LeftBrace,
+      RightBrace,
+      Comma,
+      DotDotDot,
+      Dot,
+      // JSX
+      JSXCloseTagStart,
+      JSXSelfClosing
+    ]);
+    this.RULE("program", () => {
+      let lastStatementStartLine = 0;
+      this.MANY(() => {
+        const currentToken = this.LA(1);
+        if (currentToken && lastStatementStartLine > 0) {
+          const isExportOrImport = currentToken.tokenType === Export || currentToken.tokenType === Import;
+          if (!isExportOrImport && currentToken.startLine <= lastStatementStartLine) {
+            throw new Error(`Statements must be separated by newlines. Found statement starting at line ${currentToken.startLine}, column ${currentToken.startColumn} on the same line as previous statement (started at line ${lastStatementStartLine}).`);
+          }
+        }
+        this.SUBRULE(this.statement);
+        if (currentToken) {
+          lastStatementStartLine = currentToken.startLine;
+        }
+      });
+    });
+    this.RULE("statement", () => {
+      this.OR([
+        // Modifier on block: @modifier:\n  ...
+        {
+          GATE: () => {
+            const la1 = this.LA(1);
+            const la2 = this.LA(2);
+            return la1 && la1.tokenType.name === "Modifier" && la2 && la2.tokenType === Colon;
+          },
+          ALT: () => {
+            this.SUBRULE(this.modifierBlockStatement);
+          }
+        },
+        { ALT: () => this.SUBRULE(this.exportStatement) },
+        { ALT: () => this.SUBRULE(this.importStatement) },
+        { ALT: () => this.SUBRULE(this.returnStatement) },
+        { ALT: () => this.SUBRULE(this.expressionStatement) }
+      ]);
+    });
+    this.RULE("modifierBlockStatement", () => {
+      this.CONSUME(Modifier);
+      this.CONSUME(Colon);
+      this.SUBRULE(this.blockStatement);
+    });
+    this.RULE("exportStatement", () => {
+      this.CONSUME(Export);
+      this.OR([
+        {
+          // export default expression
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === Default;
+          },
+          ALT: () => {
+            this.CONSUME(Default);
+            this.SUBRULE(this.expression);
+          }
+        },
+        {
+          // export { x, y } or export { x as y }
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === LeftBrace;
+          },
+          ALT: () => {
+            this.CONSUME(LeftBrace);
+            this.OPTION(() => {
+              this.SUBRULE(this.exportSpecifierList);
+            });
+            this.CONSUME(RightBrace);
+          }
+        },
+        {
+          // export x = 1 (named export of assignment)
+          ALT: () => {
+            this.SUBRULE(this.expressionStatement);
+          }
+        }
+      ]);
+    });
+    this.RULE("exportSpecifierList", () => {
+      this.SUBRULE(this.exportSpecifier);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.SUBRULE1(this.exportSpecifier);
+      });
+      this.OPTION(() => {
+        this.CONSUME1(Comma);
+      });
+    });
+    this.RULE("exportSpecifier", () => {
+      this.CONSUME(Identifier);
+      this.OPTION(() => {
+        this.CONSUME(As);
+        this.CONSUME1(Identifier);
+      });
+    });
+    this.RULE("importStatement", () => {
+      this.CONSUME(Import);
+      this.OR([
+        {
+          // import * as ns from "module"
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === Star;
+          },
+          ALT: () => {
+            this.CONSUME(Star);
+            this.CONSUME(As);
+            this.CONSUME(Identifier);
+            this.CONSUME(From);
+            this.CONSUME(StringLiteral);
+          }
+        },
+        {
+          // import defaultName from "module" or import defaultName, { x } from "module"
+          ALT: () => {
+            this.CONSUME1(Identifier);
+            this.OPTION(() => {
+              this.CONSUME(Comma);
+              this.CONSUME(LeftBrace);
+              this.OPTION1(() => {
+                this.SUBRULE(this.importSpecifierList);
+              });
+              this.CONSUME(RightBrace);
+            });
+            this.CONSUME1(From);
+            this.CONSUME1(StringLiteral);
+          }
+        },
+        {
+          // import { x, y } from "module"
+          ALT: () => {
+            this.CONSUME1(LeftBrace);
+            this.OPTION2(() => {
+              this.SUBRULE1(this.importSpecifierList);
+            });
+            this.CONSUME1(RightBrace);
+            this.CONSUME2(From);
+            this.CONSUME2(StringLiteral);
+          }
+        }
+      ]);
+    });
+    this.RULE("importSpecifierList", () => {
+      this.SUBRULE(this.importSpecifier);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.SUBRULE1(this.importSpecifier);
+      });
+      this.OPTION(() => {
+        this.CONSUME1(Comma);
+      });
+    });
+    this.RULE("importSpecifier", () => {
+      this.CONSUME(Identifier);
+      this.OPTION(() => {
+        this.CONSUME(As);
+        this.CONSUME1(Identifier);
+      });
+    });
+    this.RULE("returnStatement", () => {
+      this.OPTION1(() => {
+        this.CONSUME(Modifier);
+      });
+      this.CONSUME(Return);
+      this.OPTION2(() => {
+        this.SUBRULE(this.expression);
+      });
+    });
+    this.RULE("expressionStatement", () => {
+      this.OPTION1(() => {
+        this.CONSUME(Modifier);
+      });
+      this.SUBRULE(this.expression);
+    });
+    this.RULE("blockStatement", () => {
+      this.CONSUME(LeftBrace);
+      this.MANY(() => {
+        this.SUBRULE(this.statement);
+      });
+      this.CONSUME(RightBrace);
+    });
+    this.RULE("expression", () => {
+      this.SUBRULE(this.assignment);
+    });
+    this.RULE("destructuringPattern", () => {
+      this.OR([
+        {
+          // Array pattern: [a, b, ...rest]
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === LeftBracket;
+          },
+          ALT: () => {
+            this.CONSUME(LeftBracket);
+            this.OPTION1(() => {
+              this.SUBRULE(this.arrayDestructuringList);
+            });
+            this.CONSUME(RightBracket);
+          }
+        },
+        {
+          // Object pattern: {a, b, ...rest}
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === LeftBrace;
+          },
+          ALT: () => {
+            this.CONSUME(LeftBrace);
+            this.OPTION2(() => {
+              this.SUBRULE(this.objectDestructuringList);
+            });
+            this.CONSUME(RightBrace);
+          }
+        }
+      ]);
+    });
+    this.RULE("arrayDestructuringList", () => {
+      this.OR([
+        {
+          // Rest element: ...rest
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === DotDotDot;
+          },
+          ALT: () => {
+            this.CONSUME(DotDotDot);
+            this.CONSUME(Identifier);
+          }
+        },
+        {
+          // Regular element: identifier or nested pattern
+          ALT: () => {
+            this.OR1([
+              { ALT: () => this.SUBRULE(this.destructuringPattern) },
+              { ALT: () => this.CONSUME1(Identifier) }
+            ]);
+          }
+        }
+      ]);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.OR2([
+          {
+            // Rest element: ...rest (must be last)
+            GATE: () => {
+              const la1 = this.LA(1);
+              return la1 && la1.tokenType === DotDotDot;
+            },
+            ALT: () => {
+              this.CONSUME1(DotDotDot);
+              this.CONSUME2(Identifier);
+            }
+          },
+          {
+            // Regular element: identifier or nested pattern
+            ALT: () => {
+              this.OR3([
+                { ALT: () => this.SUBRULE1(this.destructuringPattern) },
+                { ALT: () => this.CONSUME3(Identifier) }
+              ]);
+            }
+          }
+        ]);
+      });
+      this.OPTION(() => {
+        this.CONSUME1(Comma);
+      });
+    });
+    this.RULE("objectDestructuringList", () => {
+      this.OR([
+        {
+          // Rest property: ...rest
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === DotDotDot;
+          },
+          ALT: () => {
+            this.CONSUME(DotDotDot);
+            this.CONSUME(Identifier);
+          }
+        },
+        {
+          // Regular property: key or key: identifier, optionally with default value
+          ALT: () => {
+            this.OR1([
+              { ALT: () => this.CONSUME1(Identifier) },
+              { ALT: () => this.CONSUME(StringLiteral) }
+            ]);
+            this.OPTION(() => {
+              this.CONSUME(Colon);
+              this.OR2([
+                { ALT: () => this.SUBRULE(this.destructuringPattern) },
+                { ALT: () => this.CONSUME2(Identifier) }
+              ]);
+            });
+            this.OPTION3(() => {
+              this.CONSUME(Equal);
+              this.SUBRULE(this.expression);
+            });
+          }
+        }
+      ]);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.OR3([
+          {
+            // Rest property: ...rest (must be last)
+            GATE: () => {
+              const la1 = this.LA(1);
+              return la1 && la1.tokenType === DotDotDot;
+            },
+            ALT: () => {
+              this.CONSUME1(DotDotDot);
+              this.CONSUME3(Identifier);
+            }
+          },
+          {
+            // Regular property: key or key: identifier, optionally with default value
+            ALT: () => {
+              this.OR4([
+                { ALT: () => this.CONSUME4(Identifier) },
+                { ALT: () => this.CONSUME1(StringLiteral) }
+              ]);
+              this.OPTION1(() => {
+                this.CONSUME1(Colon);
+                this.OR5([
+                  { ALT: () => this.SUBRULE1(this.destructuringPattern) },
+                  { ALT: () => this.CONSUME5(Identifier) }
+                ]);
+              });
+              this.OPTION4(() => {
+                this.CONSUME1(Equal);
+                this.SUBRULE2(this.expression);
+              });
+            }
+          }
+        ]);
+      });
+      this.OPTION2(() => {
+        this.CONSUME2(Comma);
+      });
+    });
+    this.RULE("assignment", () => {
+      this.OR([
+        {
+          // Destructuring assignment: [pattern] = or {pattern} = or [pattern] := or {pattern} :=
+          // Only match if we have [ or { and can find an = or := token after a valid pattern
+          GATE: () => {
+            const la1 = this.LA(1);
+            if (!la1) return false;
+            if (la1.tokenType !== LeftBracket && la1.tokenType !== LeftBrace) {
+              return false;
+            }
+            let depth = 1;
+            let i = 2;
+            while (i < MAX_TOKEN_LOOKAHEAD_COUNT) {
+              const token = this.LA(i);
+              if (!token) break;
+              if (token.tokenType === LeftBracket || token.tokenType === LeftBrace) {
+                depth++;
+              } else if (token.tokenType.name === "RightBracket" || token.tokenType.name === "RightBrace") {
+                depth--;
+                if (depth === 0) {
+                  const nextToken = this.LA(i + 1);
+                  return nextToken && (nextToken.tokenType === Equal || nextToken.tokenType === ColonEqual);
+                }
+              }
+              i++;
+            }
+            return false;
+          },
+          ALT: () => {
+            this.SUBRULE(this.destructuringPattern);
+            this.OR2([
+              { ALT: () => this.CONSUME1(Equal) },
+              { ALT: () => this.CONSUME1(ColonEqual) }
+            ]);
+            this.SUBRULE(this.assignment);
+          }
+        },
+        {
+          // Regular assignment: expr = expr or expr := expr
+          ALT: () => {
+            this.SUBRULE(this.conditional);
+            this.OPTION(() => {
+              this.OR1([
+                { ALT: () => this.CONSUME(Equal) },
+                { ALT: () => this.CONSUME(ColonEqual) },
+                { ALT: () => this.CONSUME(PlusColonEqual) },
+                { ALT: () => this.CONSUME(MinusColonEqual) },
+                { ALT: () => this.CONSUME(StarColonEqual) },
+                { ALT: () => this.CONSUME(SlashColonEqual) },
+                { ALT: () => this.CONSUME(PercentColonEqual) },
+                { ALT: () => this.CONSUME(StarStarColonEqual) },
+                { ALT: () => this.CONSUME(LeftShiftColonEqual) },
+                { ALT: () => this.CONSUME(RightShiftColonEqual) },
+                { ALT: () => this.CONSUME(UnsignedRightShiftColonEqual) },
+                { ALT: () => this.CONSUME(AndColonEqual) },
+                { ALT: () => this.CONSUME(CaretColonEqual) },
+                { ALT: () => this.CONSUME(OrColonEqual) }
+              ]);
+              this.SUBRULE1(this.assignment);
+            });
+          }
+        }
+      ]);
+    });
+    this.RULE("conditional", () => {
+      this.SUBRULE(this.logicalOr);
+      this.OPTION(() => {
+        this.CONSUME(Question);
+        this.SUBRULE(this.expression);
+        this.CONSUME(Colon);
+        this.SUBRULE(this.conditional);
+      });
+    });
+    this.RULE("logicalOr", () => {
+      this.SUBRULE(this.pipe);
+      this.MANY(() => {
+        this.CONSUME(OrOr);
+        this.SUBRULE2(this.pipe);
+      });
+    });
+    this.RULE("pipe", () => {
+      this.SUBRULE(this.compose);
+      this.MANY(() => {
+        this.CONSUME(Pipe);
+        this.SUBRULE2(this.compose);
+      });
+    });
+    this.RULE("compose", () => {
+      this.SUBRULE(this.nullishCoalescing);
+      this.OPTION(() => {
+        this.CONSUME(Compose);
+        this.SUBRULE(this.compose);
+      });
+    });
+    this.RULE("nullishCoalescing", () => {
+      this.SUBRULE(this.logicalAnd);
+      this.MANY(() => {
+        this.CONSUME(QuestionQuestion);
+        this.SUBRULE2(this.logicalAnd);
+      });
+    });
+    this.RULE("logicalAnd", () => {
+      this.SUBRULE(this.equality);
+      this.MANY(() => {
+        this.CONSUME(AndAnd);
+        this.SUBRULE2(this.equality);
+      });
+    });
+    this.RULE("equality", () => {
+      this.SUBRULE(this.relational);
+      this.MANY(() => {
+        this.OR([
+          { ALT: () => this.CONSUME(EqualEqual) },
+          { ALT: () => this.CONSUME(BangEqual) }
+        ]);
+        this.SUBRULE2(this.relational);
+      });
+    });
+    this.RULE("relational", () => {
+      this.SUBRULE(this.additive);
+      let lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : null;
+      this.MANY(() => {
+        const nextToken = this.LA(1);
+        if (nextToken && (nextToken.tokenType === LessThan || nextToken.tokenType === GreaterThan)) {
+          if (lastTokenLine && nextToken.startLine > lastTokenLine) {
+            return;
+          }
+        }
+        this.OR([
+          { ALT: () => this.CONSUME(LessThanEqual) },
+          { ALT: () => this.CONSUME(GreaterThanEqual) },
+          { ALT: () => this.CONSUME(LessThan) },
+          { ALT: () => this.CONSUME(GreaterThan) },
+          { ALT: () => this.CONSUME(Instanceof) },
+          { ALT: () => this.CONSUME(In) }
+        ]);
+        this.SUBRULE2(this.additive);
+        lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+      });
+    });
+    this.RULE("additive", () => {
+      this.SUBRULE(this.multiplicative);
+      this.MANY(() => {
+        this.OR([
+          { ALT: () => this.CONSUME(Plus) },
+          { ALT: () => this.CONSUME(Minus) }
+        ]);
+        this.SUBRULE2(this.multiplicative);
+      });
+    });
+    this.RULE("multiplicative", () => {
+      this.SUBRULE(this.exponentiation);
+      this.MANY(() => {
+        this.OR([
+          { ALT: () => this.CONSUME(Star) },
+          { ALT: () => this.CONSUME(Slash) },
+          { ALT: () => this.CONSUME(Percent) }
+        ]);
+        this.SUBRULE2(this.exponentiation);
+      });
+    });
+    this.RULE("exponentiation", () => {
+      this.SUBRULE(this.unary);
+      this.OPTION(() => {
+        this.CONSUME(StarStar);
+        this.SUBRULE(this.exponentiation);
+      });
+    });
+    this.RULE("unary", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.OR1([
+              { ALT: () => this.CONSUME(Typeof) },
+              { ALT: () => this.CONSUME(Void) },
+              { ALT: () => this.CONSUME(Delete) }
+            ]);
+            this.SUBRULE1(this.unary);
+          }
+        },
+        {
+          ALT: () => {
+            this.OR2([
+              { ALT: () => this.CONSUME(Plus) },
+              { ALT: () => this.CONSUME(Minus) },
+              { ALT: () => this.CONSUME(Bang) },
+              { ALT: () => this.CONSUME(Tilde) }
+            ]);
+            this.SUBRULE2(this.unary);
+          }
+        },
+        {
+          ALT: () => {
+            this.OR3([
+              { ALT: () => this.CONSUME(PlusPlus) },
+              { ALT: () => this.CONSUME(MinusMinus) }
+            ]);
+            this.SUBRULE1(this.postfix);
+          }
+        },
+        { ALT: () => this.SUBRULE2(this.postfix) }
+      ]);
+    });
+    this.RULE("postfix", () => {
+      this.SUBRULE(this.functionCall);
+      this.OPTION(() => {
+        this.OR([
+          { ALT: () => this.CONSUME(PlusPlus) },
+          { ALT: () => this.CONSUME(MinusMinus) }
+        ]);
+      });
+    });
+    this.RULE("functionCall", () => {
+      this.SUBRULE(this.memberAccess);
+      let lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : null;
+      this.MANY(() => {
+        const nextToken = this.LA(1);
+        if (nextToken && (nextToken.tokenType === LeftParen || nextToken.tokenType === QuestionDot && this.LA(2) && this.LA(2).tokenType === LeftParen)) {
+          if (lastTokenLine && nextToken.startLine > lastTokenLine) {
+            return;
+          }
+        }
+        this.OR([
+          {
+            // Template literals are allowed across lines (for tagged templates)
+            GATE: () => {
+              const la1 = this.LA(1);
+              return la1 && la1.tokenType === TemplateLiteral;
+            },
+            ALT: () => {
+              this.CONSUME(TemplateLiteral);
+              lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+            }
+          },
+          {
+            // Optional function call: fn?.(...)
+            // NOT allowed across lines (checked above)
+            ALT: () => {
+              this.CONSUME(QuestionDot);
+              this.CONSUME(LeftParen);
+              this.OPTION(() => {
+                this.SUBRULE(this.argumentList);
+              });
+              this.CONSUME(RightParen);
+              lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+            }
+          },
+          {
+            // Regular function call: fn(...)
+            // NOT allowed across lines (checked above)
+            ALT: () => {
+              this.CONSUME1(LeftParen);
+              this.OPTION8(() => {
+                this.SUBRULE1(this.argumentList);
+              });
+              this.CONSUME1(RightParen);
+              lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+            }
+          }
+        ]);
+        this.OPTION1(() => {
+          this.MANY1(() => {
+            const nextToken2 = this.LA(1);
+            if (nextToken2 && (nextToken2.tokenType === LeftBracket || nextToken2.tokenType === QuestionDot && this.LA(2) && this.LA(2).tokenType === LeftBracket)) {
+              if (lastTokenLine && nextToken2.startLine > lastTokenLine) {
+                return;
+              }
+            }
+            this.OR1([
+              {
+                // Optional chaining property access: obj?.prop
+                // Allowed across lines for method chaining
+                ALT: () => {
+                  this.CONSUME1(QuestionDot);
+                  this.CONSUME1(Identifier);
+                  lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+                }
+              },
+              {
+                // Regular property access: obj.prop
+                // Allowed across lines for method chaining
+                ALT: () => {
+                  this.CONSUME(Dot);
+                  this.CONSUME2(Identifier);
+                  lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+                }
+              },
+              {
+                // Optional chaining bracket access: obj?.[expr]
+                // NOT allowed across lines (checked above)
+                ALT: () => {
+                  this.CONSUME2(QuestionDot);
+                  this.CONSUME(LeftBracket);
+                  const la1 = this.LA(1);
+                  if (la1 && la1.tokenType === DotDotDot) {
+                    this.CONSUME(DotDotDot);
+                    this.CONSUME(RightBracket);
+                  } else {
+                    this.OPTION2(() => {
+                      this.SUBRULE(this.expression);
+                    });
+                    this.OPTION3(() => {
+                      this.CONSUME(DotDotDot);
+                      this.OPTION4(() => {
+                        this.SUBRULE1(this.expression);
+                      });
+                    });
+                    this.CONSUME(RightBracket);
+                  }
+                  lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+                }
+              },
+              {
+                // Regular bracket access: obj[expr]
+                // NOT allowed across lines (checked above)
+                ALT: () => {
+                  this.CONSUME1(LeftBracket);
+                  const la1 = this.LA(1);
+                  if (la1 && la1.tokenType === DotDotDot) {
+                    this.CONSUME1(DotDotDot);
+                    this.CONSUME1(RightBracket);
+                  } else {
+                    this.OPTION5(() => {
+                      this.SUBRULE2(this.expression);
+                    });
+                    this.OPTION6(() => {
+                      this.CONSUME2(DotDotDot);
+                      this.OPTION7(() => {
+                        this.SUBRULE3(this.expression);
+                      });
+                    });
+                    this.CONSUME2(RightBracket);
+                  }
+                  lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+                }
+              }
+            ]);
+          });
+        });
+      });
+    });
+    this.RULE("argumentList", () => {
+      this.OR([
+        {
+          // Spread argument: ...expr
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === DotDotDot;
+          },
+          ALT: () => {
+            this.CONSUME(DotDotDot);
+            this.SUBRULE(this.expression);
+          }
+        },
+        {
+          // Regular argument: expr
+          ALT: () => {
+            this.SUBRULE1(this.expression);
+          }
+        }
+      ]);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.OR1([
+          {
+            // Spread argument: ...expr
+            GATE: () => {
+              const la1 = this.LA(1);
+              return la1 && la1.tokenType === DotDotDot;
+            },
+            ALT: () => {
+              this.CONSUME1(DotDotDot);
+              this.SUBRULE2(this.expression);
+            }
+          },
+          {
+            // Regular argument: expr
+            ALT: () => {
+              this.SUBRULE3(this.expression);
+            }
+          }
+        ]);
+      });
+      this.OPTION(() => {
+        this.CONSUME2(Comma);
+      });
+    });
+    this.RULE("memberAccess", () => {
+      this.SUBRULE(this.primary);
+      let lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : null;
+      this.MANY(() => {
+        const nextToken = this.LA(1);
+        if (nextToken && nextToken.tokenType === QuestionDot) {
+          const tokenAfter = this.LA(2);
+          if (tokenAfter && tokenAfter.tokenType === LeftParen) {
+            return;
+          }
+        }
+        if (nextToken && (nextToken.tokenType === LeftBracket || nextToken.tokenType === QuestionDot && this.LA(2) && this.LA(2).tokenType === LeftBracket)) {
+          if (lastTokenLine && nextToken.startLine > lastTokenLine) {
+            return;
+          }
+        }
+        this.OR([
+          {
+            // Optional chaining property access: obj?.prop
+            // But NOT obj?.(  which is a function call
+            // Allowed across lines for method chaining
+            GATE: () => {
+              const la1 = this.LA(1);
+              const la2 = this.LA(2);
+              return la1 && la1.tokenType === QuestionDot && la2 && la2.tokenType === Identifier;
+            },
+            ALT: () => {
+              this.CONSUME(QuestionDot);
+              this.CONSUME(Identifier);
+              lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+            }
+          },
+          {
+            // Regular property access: obj.prop
+            // Allowed across lines for method chaining
+            ALT: () => {
+              this.CONSUME(Dot);
+              this.CONSUME1(Identifier);
+              lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+            }
+          },
+          {
+            // Optional chaining bracket access: obj?.[expr]
+            // NOT allowed across lines (checked above)
+            GATE: () => {
+              const la1 = this.LA(1);
+              const la2 = this.LA(2);
+              return la1 && la1.tokenType === QuestionDot && la2 && la2.tokenType === LeftBracket;
+            },
+            ALT: () => {
+              this.CONSUME1(QuestionDot);
+              this.CONSUME(LeftBracket);
+              const la1 = this.LA(1);
+              if (la1 && la1.tokenType === DotDotDot) {
+                const la2 = this.LA(2);
+                if (la2 && la2.tokenType === RightBracket) {
+                  this.CONSUME(DotDotDot);
+                  this.CONSUME(RightBracket);
+                } else {
+                  this.CONSUME(DotDotDot);
+                  this.CONSUME(RightBracket);
+                }
+              } else {
+                this.SUBRULE(this.expression);
+                const laAfterExpr = this.LA(1);
+                if (laAfterExpr && laAfterExpr.tokenType === DotDotDot) {
+                  const laAfterDotDotDot = this.LA(2);
+                  if (laAfterDotDotDot && laAfterDotDotDot.tokenType !== RightBracket) {
+                    this.CONSUME(DotDotDot);
+                    this.SUBRULE1(this.expression);
+                    this.CONSUME(RightBracket);
+                  } else {
+                    this.CONSUME(DotDotDot);
+                    this.CONSUME(RightBracket);
+                  }
+                } else {
+                  this.CONSUME(RightBracket);
+                }
+              }
+              lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+            }
+          },
+          {
+            // Regular bracket access: obj[expr]
+            // NOT allowed across lines (checked above)
+            ALT: () => {
+              this.CONSUME1(LeftBracket);
+              const la1 = this.LA(1);
+              if (la1 && la1.tokenType === DotDotDot) {
+                const la2 = this.LA(2);
+                if (la2 && la2.tokenType === RightBracket) {
+                  this.CONSUME1(DotDotDot);
+                  this.CONSUME1(RightBracket);
+                } else {
+                  this.CONSUME2(DotDotDot);
+                  this.CONSUME2(RightBracket);
+                }
+              } else {
+                this.SUBRULE1(this.expression);
+                const laAfterExpr = this.LA(1);
+                if (laAfterExpr && laAfterExpr.tokenType === DotDotDot) {
+                  const laAfterDotDotDot = this.LA(2);
+                  if (laAfterDotDotDot && laAfterDotDotDot.tokenType !== RightBracket) {
+                    this.CONSUME3(DotDotDot);
+                    this.SUBRULE2(this.expression);
+                    this.CONSUME3(RightBracket);
+                  } else {
+                    this.CONSUME4(DotDotDot);
+                    this.CONSUME4(RightBracket);
+                  }
+                } else {
+                  this.CONSUME5(RightBracket);
+                }
+              }
+              lastTokenLine = this.LA(0) ? this.LA(0).endLine || this.LA(0).startLine : lastTokenLine;
+            }
+          }
+        ]);
+      });
+    });
+    this.RULE("primary", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.literal) },
+        { ALT: () => this.SUBRULE(this.arrayLiteral) },
+        { ALT: () => this.SUBRULE(this.objectLiteral) },
+        {
+          // JSX Fragment: <> ... </>
+          GATE: () => {
+            const la1 = this.LA(1);
+            const la2 = this.LA(2);
+            return la1 && la1.tokenType === LessThan && la2 && la2.tokenType === GreaterThan;
+          },
+          ALT: () => this.SUBRULE(this.jsxFragment)
+        },
+        {
+          // JSX Element: <TagName ...> or <TagName />
+          GATE: () => {
+            const la1 = this.LA(1);
+            const la2 = this.LA(2);
+            return la1 && la1.tokenType === LessThan && la2 && la2.tokenType === Identifier;
+          },
+          ALT: () => this.SUBRULE(this.jsxElement)
+        },
+        // Single-param arrow function (unambiguous: x =>)
+        {
+          GATE: () => {
+            const la1 = this.LA(1);
+            const la2 = this.LA(2);
+            const la3 = this.LA(3);
+            return la1 && la1.tokenType === Identifier && la2 && la2.tokenType === Equal && la3 && la3.tokenType === GreaterThan;
+          },
+          ALT: () => this.SUBRULE(this.arrowFunction)
+        },
+        // Parenthesized expression or multi-param arrow function
+        { ALT: () => this.SUBRULE(this.parenthesizedExpression) },
+        { ALT: () => this.SUBRULE(this.identifier) }
+      ]);
+    });
+    this.RULE("literal", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(NumberLiteral) },
+        { ALT: () => this.CONSUME(StringLiteral) },
+        { ALT: () => this.SUBRULE(this.templateLiteral) },
+        { ALT: () => this.CONSUME(True) },
+        { ALT: () => this.CONSUME(False) },
+        { ALT: () => this.CONSUME(Null) }
+      ]);
+    });
+    this.RULE("templateLiteral", () => {
+      this.CONSUME(TemplateLiteral);
+    });
+    this.RULE("arrayLiteral", () => {
+      this.CONSUME(LeftBracket);
+      this.OPTION(() => {
+        this.SUBRULE(this.arrayElementList);
+      });
+      this.CONSUME(RightBracket);
+    });
+    this.RULE("arrayElementList", () => {
+      this.OR([
+        {
+          // Spread element: ...expr
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === DotDotDot;
+          },
+          ALT: () => {
+            this.CONSUME(DotDotDot);
+            this.SUBRULE(this.expression);
+          }
+        },
+        {
+          // Regular element: expr
+          ALT: () => {
+            this.SUBRULE1(this.expression);
+          }
+        }
+      ]);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.OR1([
+          {
+            // Spread element: ...expr
+            GATE: () => {
+              const la1 = this.LA(1);
+              return la1 && la1.tokenType === DotDotDot;
+            },
+            ALT: () => {
+              this.CONSUME1(DotDotDot);
+              this.SUBRULE2(this.expression);
+            }
+          },
+          {
+            // Regular element: expr
+            ALT: () => {
+              this.SUBRULE3(this.expression);
+            }
+          }
+        ]);
+      });
+      this.OPTION(() => {
+        this.CONSUME1(Comma);
+      });
+    });
+    this.RULE("objectLiteral", () => {
+      this.CONSUME(LeftBrace);
+      this.OPTION(() => {
+        this.SUBRULE(this.objectPropertyList);
+      });
+      this.CONSUME(RightBrace);
+    });
+    this.RULE("objectPropertyList", () => {
+      this.SUBRULE(this.objectProperty);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.SUBRULE2(this.objectProperty);
+      });
+      this.OPTION(() => {
+        this.CONSUME1(Comma);
+      });
+    });
+    this.RULE("objectProperty", () => {
+      this.OR([
+        {
+          // Spread property: ...expr
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === DotDotDot;
+          },
+          ALT: () => {
+            this.CONSUME(DotDotDot);
+            this.SUBRULE(this.expression);
+          }
+        },
+        {
+          // Computed key: [expr]: value
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === LeftBracket;
+          },
+          ALT: () => {
+            this.CONSUME(LeftBracket);
+            this.SUBRULE1(this.expression);
+            this.CONSUME(RightBracket);
+            this.CONSUME(Colon);
+            this.SUBRULE2(this.expression);
+          }
+        },
+        {
+          ALT: () => {
+            this.OR1([
+              { ALT: () => this.CONSUME1(Identifier) },
+              { ALT: () => this.CONSUME(StringLiteral) }
+            ]);
+            this.CONSUME1(Colon);
+            this.SUBRULE3(this.expression);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME2(Identifier);
+          }
+        }
+      ]);
+    });
+    this.RULE("arrowFunction", () => {
+      this.CONSUME(Identifier);
+      this.CONSUME(Equal);
+      this.CONSUME(GreaterThan);
+      this.OR([
+        {
+          // Block body: x => { ... }
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === LeftBrace;
+          },
+          ALT: () => {
+            this.SUBRULE(this.blockStatement);
+          }
+        },
+        {
+          // Expression body: x => expr
+          ALT: () => {
+            this.SUBRULE(this.expression);
+          }
+        }
+      ]);
+    });
+    this.RULE("parameterList", () => {
+      this.OR([
+        {
+          // Rest parameter: ...rest
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === DotDotDot;
+          },
+          ALT: () => {
+            this.CONSUME(DotDotDot);
+            this.CONSUME(Identifier);
+          }
+        },
+        {
+          // Destructuring pattern: [a, b] or {a, b} or [a, b] = default or {a, b} = default
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && (la1.tokenType === LeftBracket || la1.tokenType === LeftBrace);
+          },
+          ALT: () => {
+            this.SUBRULE(this.destructuringPattern);
+            this.OPTION(() => {
+              this.CONSUME(Equal);
+              this.SUBRULE(this.expression);
+            });
+          }
+        },
+        {
+          // Regular parameter: identifier or identifier = expression
+          ALT: () => {
+            this.CONSUME1(Identifier);
+            this.OPTION1(() => {
+              this.CONSUME1(Equal);
+              this.SUBRULE1(this.expression);
+            });
+          }
+        }
+      ]);
+      this.MANY(() => {
+        this.CONSUME(Comma);
+        this.OR1([
+          {
+            // Rest parameter: ...rest (must be last)
+            GATE: () => {
+              const la1 = this.LA(1);
+              return la1 && la1.tokenType === DotDotDot;
+            },
+            ALT: () => {
+              this.CONSUME1(DotDotDot);
+              this.CONSUME2(Identifier);
+            }
+          },
+          {
+            // Destructuring pattern: [a, b] or {a, b} or [a, b] = default or {a, b} = default
+            GATE: () => {
+              const la1 = this.LA(1);
+              return la1 && (la1.tokenType === LeftBracket || la1.tokenType === LeftBrace);
+            },
+            ALT: () => {
+              this.SUBRULE1(this.destructuringPattern);
+              this.OPTION2(() => {
+                this.CONSUME2(Equal);
+                this.SUBRULE2(this.expression);
+              });
+            }
+          },
+          {
+            // Regular parameter: identifier or identifier = expression
+            ALT: () => {
+              this.CONSUME3(Identifier);
+              this.OPTION3(() => {
+                this.CONSUME3(Equal);
+                this.SUBRULE3(this.expression);
+              });
+            }
+          }
+        ]);
+      });
+      this.OPTION4(() => {
+        this.CONSUME1(Comma);
+      });
+    });
+    this.RULE("jsxElement", () => {
+      this.CONSUME(LessThan);
+      this.SUBRULE1(this.jsxElementName);
+      this.MANY1(() => {
+        this.SUBRULE(this.jsxAttribute);
+      });
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(JSXSelfClosing);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME1(GreaterThan);
+            this.MANY2(() => {
+              this.SUBRULE(this.jsxChild);
+            });
+            this.CONSUME(JSXCloseTagStart);
+            this.SUBRULE2(this.jsxElementName);
+            this.CONSUME2(GreaterThan);
+          }
+        }
+      ]);
+    });
+    this.RULE("jsxFragment", () => {
+      this.CONSUME(LessThan);
+      this.CONSUME(GreaterThan);
+      this.MANY(() => {
+        this.SUBRULE(this.jsxChild);
+      });
+      this.CONSUME(JSXCloseTagStart);
+      this.CONSUME1(GreaterThan);
+    });
+    this.RULE("jsxElementName", () => {
+      this.CONSUME(Identifier);
+      this.MANY(() => {
+        this.OR([
+          {
+            ALT: () => {
+              this.CONSUME(Dot);
+              this.CONSUME1(Identifier);
+            }
+          },
+          {
+            ALT: () => {
+              this.CONSUME(Minus);
+              this.CONSUME2(Identifier);
+            }
+          }
+        ]);
+      });
+    });
+    this.RULE("jsxAttribute", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(LeftBrace);
+            this.CONSUME(DotDotDot);
+            this.SUBRULE(this.expression);
+            this.CONSUME(RightBrace);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(Identifier);
+            this.MANY(() => {
+              this.CONSUME(Minus);
+              this.CONSUME1(Identifier);
+            });
+            this.OPTION(() => {
+              this.CONSUME(Equal);
+              this.SUBRULE(this.jsxAttributeValue);
+            });
+          }
+        }
+      ]);
+    });
+    this.RULE("jsxAttributeValue", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(StringLiteral) },
+        {
+          ALT: () => {
+            this.CONSUME(LeftBrace);
+            this.SUBRULE(this.expression);
+            this.CONSUME(RightBrace);
+          }
+        }
+      ]);
+    });
+    this.RULE("jsxChild", () => {
+      this.OR([
+        {
+          // JSX Fragment: <>...</>
+          GATE: () => {
+            const la1 = this.LA(1);
+            const la2 = this.LA(2);
+            return la1 && la1.tokenType === LessThan && la2 && la2.tokenType === GreaterThan;
+          },
+          ALT: () => this.SUBRULE(this.jsxFragment)
+        },
+        {
+          // JSX element: <tag> or </tag>
+          GATE: () => {
+            const la1 = this.LA(1);
+            const la2 = this.LA(2);
+            return la1 && la1.tokenType === LessThan && la2 && la2.tokenType === Identifier;
+          },
+          ALT: () => this.SUBRULE(this.jsxElement)
+        },
+        {
+          // JSX expression: {expr} or {} (empty expression for comments)
+          GATE: () => {
+            const la1 = this.LA(1);
+            return la1 && la1.tokenType === LeftBrace;
+          },
+          ALT: () => {
+            this.CONSUME(LeftBrace);
+            const la1 = this.LA(1);
+            if (la1 && la1.tokenType === RightBrace) {
+              this.CONSUME(RightBrace);
+            } else {
+              this.SUBRULE(this.expression);
+              this.CONSUME(RightBrace);
+            }
+          }
+        },
+        {
+          // JSX text: consume ANY tokens until we hit < or { or </
+          ALT: () => {
+            this.MANY({
+              GATE: () => {
+                const la1 = this.LA(1);
+                if (!la1) return false;
+                if (la1.tokenType === LessThan || la1.tokenType.name === "JSXCloseTagStart" || la1.tokenType === LeftBrace) {
+                  return false;
+                }
+                return true;
+              },
+              DEF: () => {
+                this.OR1([
+                  // Literals
+                  { ALT: () => this.CONSUME(Identifier) },
+                  { ALT: () => this.CONSUME(StringLiteral) },
+                  { ALT: () => this.CONSUME(NumberLiteral) },
+                  { ALT: () => this.CONSUME(TemplateLiteral) },
+                  // Keywords
+                  { ALT: () => this.CONSUME(Return) },
+                  { ALT: () => this.CONSUME(True) },
+                  { ALT: () => this.CONSUME(False) },
+                  { ALT: () => this.CONSUME(Null) },
+                  { ALT: () => this.CONSUME(Typeof) },
+                  { ALT: () => this.CONSUME(Void) },
+                  { ALT: () => this.CONSUME(Delete) },
+                  { ALT: () => this.CONSUME(Instanceof) },
+                  { ALT: () => this.CONSUME(In) },
+                  { ALT: () => this.CONSUME(Export) },
+                  { ALT: () => this.CONSUME(Import) },
+                  { ALT: () => this.CONSUME(From) },
+                  { ALT: () => this.CONSUME(Default) },
+                  { ALT: () => this.CONSUME(As) },
+                  { ALT: () => this.CONSUME(Modifier) },
+                  // Operators
+                  { ALT: () => this.CONSUME(PlusPlus) },
+                  { ALT: () => this.CONSUME(MinusMinus) },
+                  { ALT: () => this.CONSUME(StarStarColonEqual) },
+                  { ALT: () => this.CONSUME(LeftShiftColonEqual) },
+                  { ALT: () => this.CONSUME(RightShiftColonEqual) },
+                  { ALT: () => this.CONSUME(UnsignedRightShiftColonEqual) },
+                  { ALT: () => this.CONSUME(PlusColonEqual) },
+                  { ALT: () => this.CONSUME(MinusColonEqual) },
+                  { ALT: () => this.CONSUME(StarColonEqual) },
+                  { ALT: () => this.CONSUME(SlashColonEqual) },
+                  { ALT: () => this.CONSUME(PercentColonEqual) },
+                  { ALT: () => this.CONSUME(AndColonEqual) },
+                  { ALT: () => this.CONSUME(OrColonEqual) },
+                  { ALT: () => this.CONSUME(CaretColonEqual) },
+                  { ALT: () => this.CONSUME(EqualEqual) },
+                  { ALT: () => this.CONSUME(BangEqual) },
+                  { ALT: () => this.CONSUME(LessThanEqual) },
+                  { ALT: () => this.CONSUME(GreaterThanEqual) },
+                  { ALT: () => this.CONSUME(Pipe) },
+                  { ALT: () => this.CONSUME(Compose) },
+                  { ALT: () => this.CONSUME(LeftShift) },
+                  { ALT: () => this.CONSUME(UnsignedRightShift) },
+                  { ALT: () => this.CONSUME(RightShift) },
+                  { ALT: () => this.CONSUME(StarStar) },
+                  { ALT: () => this.CONSUME(AndAnd) },
+                  { ALT: () => this.CONSUME(OrOr) },
+                  { ALT: () => this.CONSUME(Equal) },
+                  { ALT: () => this.CONSUME(Plus) },
+                  { ALT: () => this.CONSUME(Minus) },
+                  { ALT: () => this.CONSUME(Star) },
+                  { ALT: () => this.CONSUME(Percent) },
+                  { ALT: () => this.CONSUME(GreaterThan) },
+                  { ALT: () => this.CONSUME(Slash) },
+                  { ALT: () => this.CONSUME(And) },
+                  { ALT: () => this.CONSUME(Or) },
+                  { ALT: () => this.CONSUME(Caret) },
+                  { ALT: () => this.CONSUME(Bang) },
+                  { ALT: () => this.CONSUME(Tilde) },
+                  { ALT: () => this.CONSUME(QuestionQuestion) },
+                  { ALT: () => this.CONSUME(Question) },
+                  { ALT: () => this.CONSUME(ColonEqual) },
+                  { ALT: () => this.CONSUME(Colon) },
+                  // Punctuation
+                  { ALT: () => this.CONSUME(LeftParen) },
+                  { ALT: () => this.CONSUME(RightParen) },
+                  { ALT: () => this.CONSUME(LeftBracket) },
+                  { ALT: () => this.CONSUME(RightBracket) },
+                  { ALT: () => this.CONSUME1(RightBrace) },
+                  { ALT: () => this.CONSUME(Comma) },
+                  { ALT: () => this.CONSUME(DotDotDot) },
+                  { ALT: () => this.CONSUME(Dot) },
+                  { ALT: () => this.CONSUME(Semicolon) },
+                  // Whitespace (if not skipped)
+                  { ALT: () => this.CONSUME(WhiteSpace) }
+                ]);
+              }
+            });
+          }
+        }
+      ]);
+    });
+    this.RULE("parenthesizedExpression", () => {
+      this.CONSUME(LeftParen);
+      this.OR([
+        {
+          // Arrow function parameter list: () =>, (a) =>, (x, y) =>, (x, ...rest) =>, (...args) =>
+          // Check if => follows the closing paren
+          GATE: () => {
+            let depth = 1;
+            let i = 1;
+            while (i < MAX_TOKEN_LOOKAHEAD_COUNT) {
+              const token = this.LA(i);
+              if (!token) break;
+              if (token.tokenType === LeftParen) depth++;
+              if (token.tokenType === RightParen) {
+                depth--;
+                if (depth === 0) {
+                  const nextToken = this.LA(i + 1);
+                  const afterNext = this.LA(i + 2);
+                  return nextToken && nextToken.tokenType === Equal && afterNext && afterNext.tokenType === GreaterThan;
+                }
+              }
+              i++;
+            }
+            return false;
+          },
+          ALT: () => {
+            this.OPTION(() => {
+              this.SUBRULE(this.parameterList);
+            });
+            this.CONSUME(RightParen);
+            this.CONSUME(Equal);
+            this.CONSUME1(GreaterThan);
+            this.OR1([
+              {
+                // Block body: (x, y) => { ... }
+                GATE: () => {
+                  const la1 = this.LA(1);
+                  return la1 && la1.tokenType === LeftBrace;
+                },
+                ALT: () => {
+                  this.SUBRULE(this.blockStatement);
+                }
+              },
+              {
+                // Expression body: (x, y) => expr
+                ALT: () => {
+                  this.SUBRULE1(this.expression);
+                }
+              }
+            ]);
+          }
+        },
+        {
+          // Regular parenthesized expression: (expr)
+          // This alternative should NOT be used if => follows (that's handled by the arrow function alternative above)
+          GATE: () => {
+            let depth = 1;
+            let i = 1;
+            while (i < MAX_TOKEN_LOOKAHEAD_COUNT) {
+              const token = this.LA(i);
+              if (!token) break;
+              if (token.tokenType === LeftParen) depth++;
+              if (token.tokenType === RightParen) {
+                depth--;
+                if (depth === 0) {
+                  const nextToken = this.LA(i + 1);
+                  const afterNext = this.LA(i + 2);
+                  if (nextToken && nextToken.tokenType === Equal && afterNext && afterNext.tokenType === GreaterThan) {
+                    return false;
+                  }
+                  return true;
+                }
+              }
+              i++;
+            }
+            return true;
+          },
+          ALT: () => {
+            this.SUBRULE2(this.expression);
+            this.CONSUME1(RightParen);
+          }
+        }
+      ]);
+    });
+    this.RULE("identifier", () => {
+      this.CONSUME(Identifier);
+    });
+    this.performSelfAnalysis();
+  }
+};
+var parser = new OddoParser();
+
+// src/ast-converter.mjs
+function getFirstChild(node, ruleName) {
+  var _a;
+  const children = (_a = node.children) == null ? void 0 : _a[ruleName];
+  return children && children.length > 0 ? children[0] : null;
+}
+function getAllChildren(node, ruleName) {
+  var _a;
+  return ((_a = node.children) == null ? void 0 : _a[ruleName]) || [];
+}
+function getFirstTokenOffset(node) {
+  if (!node) return void 0;
+  if (node.startOffset !== void 0) {
+    return node.startOffset;
+  }
+  if (node.children) {
+    for (const key in node.children) {
+      const children = node.children[key];
+      if (Array.isArray(children)) {
+        for (const child of children) {
+          const offset = getFirstTokenOffset(child);
+          if (offset !== void 0) {
+            return offset;
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function convertStatement(cst) {
+  if (cst.children.exportStatement) {
+    return convertExportStatement(getFirstChild(cst, "exportStatement"));
+  }
+  if (cst.children.importStatement) {
+    return convertImportStatement(getFirstChild(cst, "importStatement"));
+  }
+  if (cst.children.returnStatement) {
+    return convertReturnStatement(getFirstChild(cst, "returnStatement"));
+  }
+  if (cst.children.expressionStatement) {
+    return convertExpressionStatement(getFirstChild(cst, "expressionStatement"));
+  }
+  if (cst.children.modifierBlockStatement) {
+    return convertModifierBlockStatement(getFirstChild(cst, "modifierBlockStatement"));
+  }
+  return null;
+}
+function convertModifierBlockStatement(cst) {
+  var _a;
+  const modifier = (_a = cst.children.Modifier) == null ? void 0 : _a[0];
+  const block = getFirstChild(cst, "blockStatement");
+  return {
+    type: "expressionStatement",
+    modifier: modifier ? modifier.image.slice(1) : null,
+    // Remove @
+    expression: null,
+    block: block ? {
+      type: "blockStatement",
+      body: getAllChildren(block, "statement").map(convertStatement)
+    } : null
+  };
+}
+function convertReturnStatement(cst) {
+  var _a;
+  const modifier = (_a = cst.children.Modifier) == null ? void 0 : _a[0];
+  const argument = getFirstChild(cst, "expression");
+  return {
+    type: "returnStatement",
+    modifier: modifier ? modifier.image.slice(1) : null,
+    // Remove @
+    argument: argument ? convertExpression(argument) : null
+  };
+}
+function convertExpressionStatement(cst) {
+  var _a;
+  const modifier = (_a = cst.children.Modifier) == null ? void 0 : _a[0];
+  const expression = getFirstChild(cst, "expression");
+  return {
+    type: "expressionStatement",
+    modifier: modifier ? modifier.image.slice(1) : null,
+    expression: expression ? convertExpression(expression) : null,
+    block: null
+  };
+}
+function convertExportStatement(cst) {
+  if (cst.children.Default && cst.children.Default.length > 0) {
+    const expression = getFirstChild(cst, "expression");
+    return {
+      type: "exportDefaultStatement",
+      declaration: expression ? convertExpression(expression) : null
+    };
+  }
+  if (cst.children.LeftBrace && cst.children.LeftBrace.length > 0) {
+    const specifierList = getFirstChild(cst, "exportSpecifierList");
+    const specifiers = specifierList ? getAllChildren(specifierList, "exportSpecifier").map(convertExportSpecifier) : [];
+    return {
+      type: "exportNamedStatement",
+      specifiers
+    };
+  }
+  const expressionStatement2 = getFirstChild(cst, "expressionStatement");
+  if (expressionStatement2) {
+    return {
+      type: "exportNamedStatement",
+      declaration: convertExpressionStatement(expressionStatement2)
+    };
+  }
+  return null;
+}
+function convertExportSpecifier(cst) {
+  var _a, _b, _c, _d;
+  const local = (_b = (_a = cst.children.Identifier) == null ? void 0 : _a[0]) == null ? void 0 : _b.image;
+  const exported = ((_d = (_c = cst.children.Identifier) == null ? void 0 : _c[1]) == null ? void 0 : _d.image) || local;
+  return {
+    type: "exportSpecifier",
+    local,
+    exported
+  };
+}
+function convertImportStatement(cst) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (cst.children.Star && cst.children.Star.length > 0) {
+    const namespace = (_b = (_a = cst.children.Identifier) == null ? void 0 : _a[0]) == null ? void 0 : _b.image;
+    const source2 = (_e = (_d = (_c = cst.children.StringLiteral) == null ? void 0 : _c[0]) == null ? void 0 : _d.image) == null ? void 0 : _e.slice(1, -1);
+    return {
+      type: "importNamespaceStatement",
+      namespace,
+      source: source2
+    };
+  }
+  const defaultName = (_g = (_f = cst.children.Identifier) == null ? void 0 : _f[0]) == null ? void 0 : _g.image;
+  const hasComma = cst.children.Comma && cst.children.Comma.length > 0;
+  const source = (_j = (_i = (_h = cst.children.StringLiteral) == null ? void 0 : _h[0]) == null ? void 0 : _i.image) == null ? void 0 : _j.slice(1, -1);
+  if (hasComma) {
+    const specifierList = getFirstChild(cst, "importSpecifierList");
+    const specifiers = specifierList ? getAllChildren(specifierList, "importSpecifier").map(convertImportSpecifier) : [];
+    return {
+      type: "importStatement",
+      defaultImport: defaultName,
+      specifiers,
+      source
+    };
+  }
+  if (cst.children.LeftBrace && cst.children.LeftBrace.length > 0) {
+    const specifierList = getFirstChild(cst, "importSpecifierList");
+    const specifiers = specifierList ? getAllChildren(specifierList, "importSpecifier").map(convertImportSpecifier) : [];
+    return {
+      type: "importStatement",
+      defaultImport: null,
+      specifiers,
+      source
+    };
+  }
+  if (defaultName && source) {
+    return {
+      type: "importStatement",
+      defaultImport: defaultName,
+      specifiers: [],
+      source
+    };
+  }
+  return null;
+}
+function convertImportSpecifier(cst) {
+  var _a, _b, _c, _d;
+  const imported = (_b = (_a = cst.children.Identifier) == null ? void 0 : _a[0]) == null ? void 0 : _b.image;
+  const local = ((_d = (_c = cst.children.Identifier) == null ? void 0 : _c[1]) == null ? void 0 : _d.image) || imported;
+  return {
+    type: "importSpecifier",
+    imported,
+    local
+  };
+}
+function convertExpression(cst) {
+  if (!cst) return null;
+  const nodeName = cst.name;
+  if (nodeName === "assignment") return convertAssignment(cst);
+  if (nodeName === "conditional") return convertConditional(cst);
+  if (nodeName === "logicalOr") return convertLogicalOr(cst);
+  if (nodeName === "pipe") return convertPipe(cst);
+  if (nodeName === "compose") return convertCompose(cst);
+  if (nodeName === "nullishCoalescing") return convertNullishCoalescing(cst);
+  if (nodeName === "logicalAnd") return convertLogicalAnd(cst);
+  if (nodeName === "equality") return convertEquality(cst);
+  if (nodeName === "relational") return convertRelational(cst);
+  if (nodeName === "additive") return convertAdditive(cst);
+  if (nodeName === "multiplicative") return convertMultiplicative(cst);
+  if (nodeName === "exponentiation") return convertExponentiation(cst);
+  if (nodeName === "unary") return convertUnary(cst);
+  if (nodeName === "postfix") return convertPostfix(cst);
+  if (nodeName === "functionCall") return convertFunctionCall(cst);
+  if (nodeName === "memberAccess") return convertMemberAccess(cst);
+  if (nodeName === "primary") return convertPrimary(cst);
+  if (cst.children.assignment) {
+    return convertAssignment(getFirstChild(cst, "assignment"));
+  }
+  if (cst.children.conditional) {
+    return convertConditional(getFirstChild(cst, "conditional"));
+  }
+  if (cst.children.logicalOr) {
+    return convertLogicalOr(getFirstChild(cst, "logicalOr"));
+  }
+  if (cst.children.pipe) {
+    return convertPipe(getFirstChild(cst, "pipe"));
+  }
+  if (cst.children.compose) {
+    return convertCompose(getFirstChild(cst, "compose"));
+  }
+  if (cst.children.nullishCoalescing) {
+    return convertNullishCoalescing(getFirstChild(cst, "nullishCoalescing"));
+  }
+  if (cst.children.logicalAnd) {
+    return convertLogicalAnd(getFirstChild(cst, "logicalAnd"));
+  }
+  if (cst.children.equality) {
+    return convertEquality(getFirstChild(cst, "equality"));
+  }
+  if (cst.children.relational) {
+    return convertRelational(getFirstChild(cst, "relational"));
+  }
+  if (cst.children.additive) {
+    return convertAdditive(getFirstChild(cst, "additive"));
+  }
+  if (cst.children.multiplicative) {
+    return convertMultiplicative(getFirstChild(cst, "multiplicative"));
+  }
+  if (cst.children.exponentiation) {
+    return convertExponentiation(getFirstChild(cst, "exponentiation"));
+  }
+  if (cst.children.unary) {
+    return convertUnary(getFirstChild(cst, "unary"));
+  }
+  if (cst.children.postfix) {
+    return convertPostfix(getFirstChild(cst, "postfix"));
+  }
+  if (cst.children.functionCall) {
+    return convertFunctionCall(getFirstChild(cst, "functionCall"));
+  }
+  if (cst.children.memberAccess) {
+    return convertMemberAccess(getFirstChild(cst, "memberAccess"));
+  }
+  if (cst.children.primary) {
+    return convertPrimary(getFirstChild(cst, "primary"));
+  }
+  return null;
+}
+function convertDestructuringPattern(cst) {
+  if (cst.children.LeftBracket) {
+    const arrayList = getFirstChild(cst, "arrayDestructuringList");
+    return {
+      type: "arrayPattern",
+      elements: arrayList ? convertArrayDestructuringList(arrayList) : []
+    };
+  }
+  if (cst.children.LeftBrace) {
+    const objectList = getFirstChild(cst, "objectDestructuringList");
+    return {
+      type: "objectPattern",
+      properties: objectList ? convertObjectDestructuringList(objectList) : []
+    };
+  }
+  return null;
+}
+function convertArrayDestructuringList(cst) {
+  var _a, _b, _c, _d, _e;
+  const elements = [];
+  const identifiers = cst.children.Identifier || [];
+  const commas = cst.children.Comma || [];
+  const dotDotDots = cst.children.DotDotDot || [];
+  const destructuringPatterns = getAllChildren(cst, "destructuringPattern");
+  let identifierIndex = 0;
+  let patternIndex = 0;
+  let dotDotDotIndex = 0;
+  if (dotDotDotIndex < dotDotDots.length && dotDotDots[dotDotDotIndex].startOffset < (((_a = identifiers[identifierIndex]) == null ? void 0 : _a.startOffset) || Infinity)) {
+    if (identifierIndex < identifiers.length) {
+      elements.push({
+        type: "restElement",
+        argument: { type: "identifier", name: identifiers[identifierIndex].image }
+      });
+      dotDotDotIndex++;
+      identifierIndex++;
+    }
+  } else if (patternIndex < destructuringPatterns.length && destructuringPatterns[patternIndex].startOffset < (((_b = identifiers[identifierIndex]) == null ? void 0 : _b.startOffset) || Infinity)) {
+    elements.push(convertDestructuringPattern(destructuringPatterns[patternIndex]));
+    patternIndex++;
+  } else if (identifierIndex < identifiers.length) {
+    elements.push({ type: "identifier", name: identifiers[identifierIndex].image });
+    identifierIndex++;
+  }
+  for (let i = 0; i < commas.length; i++) {
+    if (dotDotDotIndex < dotDotDots.length && dotDotDots[dotDotDotIndex].startOffset < (((_c = identifiers[identifierIndex]) == null ? void 0 : _c.startOffset) || Infinity) && dotDotDots[dotDotDotIndex].startOffset < (((_d = destructuringPatterns[patternIndex]) == null ? void 0 : _d.startOffset) || Infinity)) {
+      if (identifierIndex < identifiers.length) {
+        elements.push({
+          type: "restElement",
+          argument: { type: "identifier", name: identifiers[identifierIndex].image }
+        });
+        dotDotDotIndex++;
+        identifierIndex++;
+        break;
+      }
+    } else if (patternIndex < destructuringPatterns.length && destructuringPatterns[patternIndex].startOffset < (((_e = identifiers[identifierIndex]) == null ? void 0 : _e.startOffset) || Infinity)) {
+      elements.push(convertDestructuringPattern(destructuringPatterns[patternIndex]));
+      patternIndex++;
+    } else if (identifierIndex < identifiers.length) {
+      elements.push({ type: "identifier", name: identifiers[identifierIndex].image });
+      identifierIndex++;
+    }
+  }
+  return elements;
+}
+function convertObjectDestructuringList(cst) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const properties = [];
+  const identifiers = cst.children.Identifier || [];
+  const stringLiterals = cst.children.StringLiteral || [];
+  const colons = cst.children.Colon || [];
+  const commas = cst.children.Comma || [];
+  const dotDotDots = cst.children.DotDotDot || [];
+  const equals = cst.children.Equal || [];
+  const destructuringPatterns = getAllChildren(cst, "destructuringPattern");
+  const expressions = cst.children.expression || [];
+  let idIndex = 0;
+  let strIndex = 0;
+  let colonIndex = 0;
+  let commaIndex = 0;
+  let dotDotDotIndex = 0;
+  let patternIndex = 0;
+  let exprIndex = 0;
+  if (dotDotDotIndex < dotDotDots.length && (idIndex >= identifiers.length || dotDotDots[dotDotDotIndex].startOffset < identifiers[idIndex].startOffset) && (strIndex >= stringLiterals.length || dotDotDots[dotDotDotIndex].startOffset < stringLiterals[strIndex].startOffset)) {
+    let restIdIndex = idIndex;
+    for (let j = idIndex; j < identifiers.length; j++) {
+      if (identifiers[j].startOffset > dotDotDots[dotDotDotIndex].startOffset) {
+        restIdIndex = j;
+        break;
+      }
+    }
+    if (restIdIndex < identifiers.length) {
+      properties.push({
+        type: "restProperty",
+        argument: { type: "identifier", name: identifiers[restIdIndex].image }
+      });
+      dotDotDotIndex++;
+      idIndex = restIdIndex + 1;
+      return properties;
+    }
+  }
+  let key = null;
+  let value = null;
+  if (idIndex < identifiers.length && (strIndex >= stringLiterals.length || identifiers[idIndex].startOffset < stringLiterals[strIndex].startOffset)) {
+    key = { type: "identifier", name: identifiers[idIndex].image };
+    idIndex++;
+  } else if (strIndex < stringLiterals.length) {
+    key = { type: "string", value: stringLiterals[strIndex].image.slice(1, -1) };
+    strIndex++;
+  }
+  if (colonIndex < colons.length && key) {
+    colonIndex++;
+    if (patternIndex < destructuringPatterns.length) {
+      const pattern = destructuringPatterns[patternIndex];
+      const leftBracket = (_b = (_a = pattern.children) == null ? void 0 : _a.LeftBracket) == null ? void 0 : _b[0];
+      const leftBrace = (_d = (_c = pattern.children) == null ? void 0 : _c.LeftBrace) == null ? void 0 : _d[0];
+      const patternStart = (leftBracket == null ? void 0 : leftBracket.startOffset) || (leftBrace == null ? void 0 : leftBrace.startOffset) || pattern.startOffset || 0;
+      const colon = colons[colonIndex - 1];
+      const colonEnd = colon.endOffset || colon.startOffset;
+      if (patternStart > colonEnd && (idIndex >= identifiers.length || patternStart < identifiers[idIndex].startOffset)) {
+        value = convertDestructuringPattern(pattern);
+        patternIndex++;
+      } else if (idIndex < identifiers.length) {
+        value = { type: "identifier", name: identifiers[idIndex].image };
+        idIndex++;
+      }
+    } else if (idIndex < identifiers.length) {
+      value = { type: "identifier", name: identifiers[idIndex].image };
+      idIndex++;
+    }
+    let defaultValue = null;
+    const valueEnd = value ? value.startOffset || (((_e = identifiers[idIndex - 1]) == null ? void 0 : _e.endOffset) || 0) : key.startOffset || 0;
+    const defaultEqual = equals.find((eq) => eq.startOffset > valueEnd && eq.startOffset < valueEnd + 20);
+    if (defaultEqual && expressions.length > 0) {
+      const defaultExpr = expressions.find((expr) => {
+        var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j2, _k2, _l2;
+        const exprStart = expr.startOffset || ((_f2 = (_e2 = (_d2 = (_c2 = (_b2 = (_a2 = expr.children) == null ? void 0 : _a2.number) == null ? void 0 : _b2[0]) == null ? void 0 : _c2.children) == null ? void 0 : _d2.NumberLiteral) == null ? void 0 : _e2[0]) == null ? void 0 : _f2.startOffset) || ((_l2 = (_k2 = (_j2 = (_i2 = (_h2 = (_g2 = expr.children) == null ? void 0 : _g2.identifier) == null ? void 0 : _h2[0]) == null ? void 0 : _i2.children) == null ? void 0 : _j2.Identifier) == null ? void 0 : _k2[0]) == null ? void 0 : _l2.startOffset);
+        return exprStart && exprStart > defaultEqual.startOffset && exprStart < defaultEqual.startOffset + 20;
+      });
+      if (defaultExpr) {
+        defaultValue = convertExpression(defaultExpr);
+      }
+    }
+    if (key && value) {
+      properties.push({
+        type: "property",
+        key,
+        value,
+        shorthand: false,
+        default: defaultValue
+      });
+    }
+  } else if (key) {
+    let defaultValue = null;
+    const keyEnd = key.startOffset || (((_f = identifiers[idIndex - 1]) == null ? void 0 : _f.endOffset) || 0);
+    const nextCommaStart = commas.length > 0 ? commas[0].startOffset : Infinity;
+    const defaultEqual = equals.find(
+      (eq) => eq.startOffset > keyEnd && eq.startOffset < nextCommaStart
+    );
+    if (defaultEqual && exprIndex < expressions.length) {
+      defaultValue = convertExpression(expressions[exprIndex]);
+      exprIndex++;
+    }
+    properties.push({
+      type: "property",
+      key,
+      value: key,
+      // Shorthand: same as key
+      shorthand: true,
+      default: defaultValue
+    });
+  }
+  for (let i = 0; i < commas.length; i++) {
+    const comma = commas[i];
+    let nextDotDotDot = null;
+    let nextDotDotDotIndex = -1;
+    for (let j = dotDotDotIndex; j < dotDotDots.length; j++) {
+      if (dotDotDots[j].startOffset > comma.startOffset) {
+        nextDotDotDot = dotDotDots[j];
+        nextDotDotDotIndex = j;
+        break;
+      }
+    }
+    const nextIdOffset = idIndex < identifiers.length ? identifiers[idIndex].startOffset : Infinity;
+    const nextStrOffset = strIndex < stringLiterals.length ? stringLiterals[strIndex].startOffset : Infinity;
+    const nextTokenOffset = Math.min(nextIdOffset, nextStrOffset);
+    if (nextDotDotDot && nextDotDotDot.startOffset < nextTokenOffset) {
+      let restIdIndex = idIndex;
+      for (let j = idIndex; j < identifiers.length; j++) {
+        if (identifiers[j].startOffset > nextDotDotDot.startOffset) {
+          restIdIndex = j;
+          break;
+        }
+      }
+      if (restIdIndex < identifiers.length) {
+        properties.push({
+          type: "restProperty",
+          argument: { type: "identifier", name: identifiers[restIdIndex].image }
+        });
+        dotDotDotIndex = nextDotDotDotIndex + 1;
+        idIndex = restIdIndex + 1;
+        break;
+      }
+    }
+    key = null;
+    value = null;
+    if (idIndex < identifiers.length && (strIndex >= stringLiterals.length || identifiers[idIndex].startOffset < stringLiterals[strIndex].startOffset)) {
+      key = { type: "identifier", name: identifiers[idIndex].image };
+      idIndex++;
+    } else if (strIndex < stringLiterals.length) {
+      key = { type: "string", value: stringLiterals[strIndex].image.slice(1, -1) };
+      strIndex++;
+    }
+    let defaultValue = null;
+    if (colonIndex < colons.length && key) {
+      colonIndex++;
+      if (patternIndex < destructuringPatterns.length) {
+        const pattern = destructuringPatterns[patternIndex];
+        const leftBracket = (_h = (_g = pattern.children) == null ? void 0 : _g.LeftBracket) == null ? void 0 : _h[0];
+        const leftBrace = (_j = (_i = pattern.children) == null ? void 0 : _i.LeftBrace) == null ? void 0 : _j[0];
+        const patternStart = (leftBracket == null ? void 0 : leftBracket.startOffset) || (leftBrace == null ? void 0 : leftBrace.startOffset) || pattern.startOffset || 0;
+        const colon = colons[colonIndex - 1];
+        const colonEnd = colon.endOffset || colon.startOffset;
+        if (patternStart > colonEnd && (idIndex >= identifiers.length || patternStart < identifiers[idIndex].startOffset)) {
+          value = convertDestructuringPattern(pattern);
+          patternIndex++;
+        } else if (idIndex < identifiers.length) {
+          value = { type: "identifier", name: identifiers[idIndex].image };
+          idIndex++;
+        }
+      } else if (idIndex < identifiers.length) {
+        value = { type: "identifier", name: identifiers[idIndex].image };
+        idIndex++;
+      }
+      const valueEnd = value ? value.startOffset || (((_k = identifiers[idIndex - 1]) == null ? void 0 : _k.endOffset) || 0) : key.startOffset || 0;
+      const nextCommaStart = i < commas.length - 1 ? commas[i + 1].startOffset : Infinity;
+      const defaultEqual = equals.find(
+        (eq) => eq.startOffset > valueEnd && eq.startOffset < nextCommaStart
+      );
+      if (defaultEqual && exprIndex < expressions.length) {
+        defaultValue = convertExpression(expressions[exprIndex]);
+        exprIndex++;
+      }
+      if (key && value) {
+        properties.push({
+          type: "property",
+          key,
+          value,
+          shorthand: false,
+          default: defaultValue
+        });
+      }
+    } else if (key) {
+      const keyEnd = key.startOffset || (((_l = identifiers[idIndex - 1]) == null ? void 0 : _l.endOffset) || 0);
+      const nextCommaStart = i < commas.length - 1 ? commas[i + 1].startOffset : Infinity;
+      const defaultEqual = equals.find(
+        (eq) => eq.startOffset > keyEnd && eq.startOffset < nextCommaStart
+      );
+      if (defaultEqual && exprIndex < expressions.length) {
+        defaultValue = convertExpression(expressions[exprIndex]);
+        exprIndex++;
+      }
+      properties.push({
+        type: "property",
+        key,
+        value: key,
+        shorthand: true,
+        default: defaultValue
+      });
+    }
+  }
+  return properties;
+}
+function convertAssignment(cst) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B;
+  const destructuringPattern = getFirstChild(cst, "destructuringPattern");
+  if (destructuringPattern) {
+    const opToken2 = ((_a = cst.children.Equal) == null ? void 0 : _a[0]) || ((_b = cst.children.ColonEqual) == null ? void 0 : _b[0]) || ((_c = cst.children.PlusColonEqual) == null ? void 0 : _c[0]) || ((_d = cst.children.MinusColonEqual) == null ? void 0 : _d[0]) || ((_e = cst.children.StarColonEqual) == null ? void 0 : _e[0]) || ((_f = cst.children.SlashColonEqual) == null ? void 0 : _f[0]) || ((_g = cst.children.PercentColonEqual) == null ? void 0 : _g[0]) || ((_h = cst.children.StarStarColonEqual) == null ? void 0 : _h[0]) || ((_i = cst.children.LeftShiftColonEqual) == null ? void 0 : _i[0]) || ((_j = cst.children.RightShiftColonEqual) == null ? void 0 : _j[0]) || ((_k = cst.children.UnsignedRightShiftColonEqual) == null ? void 0 : _k[0]) || ((_l = cst.children.AndColonEqual) == null ? void 0 : _l[0]) || ((_m = cst.children.CaretColonEqual) == null ? void 0 : _m[0]) || ((_n = cst.children.OrColonEqual) == null ? void 0 : _n[0]);
+    if (opToken2) {
+      const left2 = convertDestructuringPattern(destructuringPattern);
+      const right = convertExpression(getFirstChild(cst, "assignment"));
+      if (opToken2.image === "=") {
+        return {
+          type: "variableDeclaration",
+          operator: "=",
+          left: left2,
+          right
+        };
+      }
+      return {
+        type: "assignment",
+        operator: opToken2.image,
+        left: left2,
+        right
+      };
+    }
+    return convertDestructuringPattern(destructuringPattern);
+  }
+  const left = convertExpression(getFirstChild(cst, "conditional"));
+  const opToken = ((_o = cst.children.Equal) == null ? void 0 : _o[0]) || ((_p = cst.children.ColonEqual) == null ? void 0 : _p[0]) || ((_q = cst.children.PlusColonEqual) == null ? void 0 : _q[0]) || ((_r = cst.children.MinusColonEqual) == null ? void 0 : _r[0]) || ((_s = cst.children.StarColonEqual) == null ? void 0 : _s[0]) || ((_t = cst.children.SlashColonEqual) == null ? void 0 : _t[0]) || ((_u = cst.children.PercentColonEqual) == null ? void 0 : _u[0]) || ((_v = cst.children.StarStarColonEqual) == null ? void 0 : _v[0]) || ((_w = cst.children.LeftShiftColonEqual) == null ? void 0 : _w[0]) || ((_x = cst.children.RightShiftColonEqual) == null ? void 0 : _x[0]) || ((_y = cst.children.UnsignedRightShiftColonEqual) == null ? void 0 : _y[0]) || ((_z = cst.children.AndColonEqual) == null ? void 0 : _z[0]) || ((_A = cst.children.CaretColonEqual) == null ? void 0 : _A[0]) || ((_B = cst.children.OrColonEqual) == null ? void 0 : _B[0]);
+  if (opToken) {
+    const right = convertExpression(getFirstChild(cst, "assignment"));
+    if (left && left.type === "arraySlice") {
+      if (opToken.image === "=") {
+        throw new Error("Array slice assignments must use := operator, not =");
+      }
+      return {
+        type: "arraySliceAssignment",
+        slice: left,
+        value: right
+      };
+    }
+    if (left && left.type === "memberAccess") {
+      if (opToken.image === "=") {
+        throw new Error("Member access assignments must use := operator, not =");
+      }
+    }
+    if (opToken.image === "=") {
+      return {
+        type: "variableDeclaration",
+        operator: "=",
+        left,
+        right
+      };
+    }
+    return {
+      type: "assignment",
+      operator: opToken.image,
+      left,
+      right
+    };
+  }
+  return left;
+}
+function convertConditional(cst) {
+  const test = convertExpression(getFirstChild(cst, "logicalOr"));
+  const hasQuestion = cst.children.Question && cst.children.Question.length > 0;
+  if (hasQuestion) {
+    const consequent = convertExpression(getFirstChild(cst, "expression"));
+    const alternate = convertExpression(getFirstChild(cst, "conditional"));
+    return {
+      type: "conditional",
+      test,
+      consequent,
+      alternate
+    };
+  }
+  return test;
+}
+function convertLogicalOr(cst) {
+  const left = convertExpression(getFirstChild(cst, "pipe"));
+  const operators = cst.children.OrOr || [];
+  return operators.reduce((acc, _, index) => {
+    const right = convertExpression(getAllChildren(cst, "pipe")[index + 1]);
+    return {
+      type: "logical",
+      operator: "||",
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertPipe(cst) {
+  const left = convertExpression(getFirstChild(cst, "compose"));
+  const operators = cst.children.Pipe || [];
+  return operators.reduce((acc, _, index) => {
+    const right = convertExpression(getAllChildren(cst, "compose")[index + 1]);
+    return {
+      type: "pipe",
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertCompose(cst) {
+  var _a;
+  const left = convertExpression(getFirstChild(cst, "nullishCoalescing"));
+  const composeOp = (_a = cst.children.Compose) == null ? void 0 : _a[0];
+  if (composeOp) {
+    const right = convertExpression(getFirstChild(cst, "compose"));
+    return {
+      type: "compose",
+      left,
+      // Outer function (c)
+      right
+      // Inner result (b <| a)
+    };
+  }
+  return left;
+}
+function convertNullishCoalescing(cst) {
+  const left = convertExpression(getFirstChild(cst, "logicalAnd"));
+  const operators = cst.children.QuestionQuestion || [];
+  return operators.reduce((acc, _, index) => {
+    const right = convertExpression(getAllChildren(cst, "logicalAnd")[index + 1]);
+    return {
+      type: "nullishCoalescing",
+      operator: "??",
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertLogicalAnd(cst) {
+  const left = convertExpression(getFirstChild(cst, "equality"));
+  const operators = cst.children.AndAnd || [];
+  return operators.reduce((acc, _, index) => {
+    const right = convertExpression(getAllChildren(cst, "equality")[index + 1]);
+    return {
+      type: "logical",
+      operator: "&&",
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertEquality(cst) {
+  const left = convertExpression(getFirstChild(cst, "relational"));
+  const operators = [
+    ...cst.children.EqualEqual || [],
+    ...cst.children.BangEqual || []
+  ];
+  return operators.reduce((acc, op, index) => {
+    const right = convertExpression(getAllChildren(cst, "relational")[index + 1]);
+    return {
+      type: "binary",
+      operator: op.image,
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertRelational(cst) {
+  const left = convertExpression(getFirstChild(cst, "additive"));
+  const operators = [
+    ...cst.children.LessThanEqual || [],
+    ...cst.children.GreaterThanEqual || [],
+    ...cst.children.LessThan || [],
+    ...cst.children.GreaterThan || [],
+    ...cst.children.Instanceof || [],
+    ...cst.children.In || []
+  ];
+  return operators.reduce((acc, op, index) => {
+    const right = convertExpression(getAllChildren(cst, "additive")[index + 1]);
+    return {
+      type: "binary",
+      operator: op.image,
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertAdditive(cst) {
+  const left = convertExpression(getFirstChild(cst, "multiplicative"));
+  const operators = [
+    ...cst.children.Plus || [],
+    ...cst.children.Minus || []
+  ];
+  return operators.reduce((acc, op, index) => {
+    const right = convertExpression(getAllChildren(cst, "multiplicative")[index + 1]);
+    return {
+      type: "binary",
+      operator: op.image,
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertMultiplicative(cst) {
+  const left = convertExpression(getFirstChild(cst, "exponentiation"));
+  const operators = [
+    ...cst.children.Star || [],
+    ...cst.children.Slash || [],
+    ...cst.children.Percent || []
+  ];
+  return operators.reduce((acc, op, index) => {
+    const right = convertExpression(getAllChildren(cst, "exponentiation")[index + 1]);
+    return {
+      type: "binary",
+      operator: op.image,
+      left: acc,
+      right
+    };
+  }, left);
+}
+function convertExponentiation(cst) {
+  const left = convertExpression(getFirstChild(cst, "unary"));
+  const hasStarStar = cst.children.StarStar && cst.children.StarStar.length > 0;
+  if (hasStarStar) {
+    const right = convertExpression(getFirstChild(cst, "exponentiation"));
+    return {
+      type: "binary",
+      operator: "**",
+      left,
+      right
+    };
+  }
+  return left;
+}
+function convertUnary(cst) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const prefixOp = ((_a = cst.children.PlusPlus) == null ? void 0 : _a[0]) || ((_b = cst.children.MinusMinus) == null ? void 0 : _b[0]);
+  if (prefixOp) {
+    const operand = convertExpression(getFirstChild(cst, "postfix"));
+    return {
+      type: "prefix",
+      operator: prefixOp.image,
+      operand
+    };
+  }
+  const unaryOp = ((_c = cst.children.Typeof) == null ? void 0 : _c[0]) || ((_d = cst.children.Void) == null ? void 0 : _d[0]) || ((_e = cst.children.Delete) == null ? void 0 : _e[0]) || ((_f = cst.children.Plus) == null ? void 0 : _f[0]) || ((_g = cst.children.Minus) == null ? void 0 : _g[0]) || ((_h = cst.children.Bang) == null ? void 0 : _h[0]) || ((_i = cst.children.Tilde) == null ? void 0 : _i[0]);
+  if (unaryOp) {
+    const operand = convertExpression(getFirstChild(cst, "unary"));
+    return {
+      type: "unary",
+      operator: unaryOp.image,
+      operand
+    };
+  }
+  return convertExpression(getFirstChild(cst, "postfix"));
+}
+function convertPostfix(cst) {
+  var _a, _b;
+  const operand = convertExpression(getFirstChild(cst, "functionCall"));
+  const op = ((_a = cst.children.PlusPlus) == null ? void 0 : _a[0]) || ((_b = cst.children.MinusMinus) == null ? void 0 : _b[0]);
+  if (op) {
+    return {
+      type: "postfix",
+      operator: op.image,
+      operand
+    };
+  }
+  return operand;
+}
+function convertFunctionCall(cst) {
+  let callee = convertExpression(getFirstChild(cst, "memberAccess"));
+  const leftParens = cst.children.LeftParen || [];
+  const questionDots = cst.children.QuestionDot || [];
+  const templateLiterals = cst.children.TemplateLiteral || [];
+  if (templateLiterals.length > 0 && leftParens.length === 0) {
+    const templateLiteral2 = convertTemplateLiteralFromToken(templateLiterals[0]);
+    return {
+      type: "taggedTemplate",
+      tag: callee,
+      template: templateLiteral2
+    };
+  }
+  const dots = cst.children.Dot || [];
+  const identifiers = cst.children.Identifier || [];
+  const brackets = cst.children.LeftBracket || [];
+  const rightBrackets = cst.children.RightBracket || [];
+  const argLists = getAllChildren(cst, "argumentList");
+  const allExprs = getAllChildren(cst, "expression");
+  const ops = [
+    ...leftParens.map((t2, i) => ({ k: "c", off: t2.startOffset, i, token: t2 })),
+    ...dots.map((t2, i) => ({ k: "d", off: t2.startOffset, i })),
+    ...brackets.map((t2, i) => {
+      var _a;
+      return { k: "b", off: t2.startOffset, i, end: (_a = rightBrackets[i]) == null ? void 0 : _a.endOffset };
+    }),
+    ...questionDots.filter((q) => !leftParens.some((p) => Math.abs(p.startOffset - q.endOffset) <= 1)).map((t2, i) => ({ k: "q", off: t2.startOffset, i }))
+  ].sort((a, b) => a.off - b.off);
+  let identIdx = 0;
+  for (const op of ops) {
+    if (op.k === "c") {
+      const isOptional = questionDots.some((q) => q.endOffset < op.token.startOffset && op.token.startOffset - q.endOffset <= 1);
+      const argsCST = argLists[op.i];
+      const args = [];
+      if (argsCST) {
+        const exprs = getAllChildren(argsCST, "expression");
+        const spreads = argsCST.children.DotDotDot || [];
+        for (const expr of exprs) {
+          const start = getFirstTokenOffset(expr);
+          const isSpread = start !== void 0 && spreads.some((s) => Math.abs(s.endOffset + 1 - start) <= 1);
+          args.push(isSpread ? { type: "spreadElement", argument: convertExpression(expr) } : convertExpression(expr));
+        }
+      }
+      callee = { type: "call", callee, arguments: args, optional: isOptional };
+    } else if (op.k === "d") {
+      const id = identifiers[identIdx++];
+      if (id) callee = { type: "memberAccess", object: callee, property: id.image, computed: false, optional: false };
+    } else if (op.k === "q") {
+      const nextBracket = brackets.find((b) => b.startOffset > op.off && b.startOffset - op.off <= 2);
+      if (nextBracket) {
+        const bIdx = brackets.indexOf(nextBracket);
+        const expr = allExprs.find((e) => {
+          var _a;
+          const o = getFirstTokenOffset(e);
+          return o > nextBracket.startOffset && o < ((_a = rightBrackets[bIdx]) == null ? void 0 : _a.endOffset);
+        });
+        if (expr) callee = { type: "memberAccess", object: callee, property: convertExpression(expr), computed: true, optional: true };
+        ops.splice(ops.findIndex((o) => o.k === "b" && o.i === bIdx), 1);
+      } else {
+        const id = identifiers[identIdx++];
+        if (id) callee = { type: "memberAccess", object: callee, property: id.image, computed: false, optional: true };
+      }
+    } else if (op.k === "b") {
+      const expr = allExprs.find((e) => {
+        const o = getFirstTokenOffset(e);
+        return o > op.off && o < op.end;
+      });
+      if (expr) callee = { type: "memberAccess", object: callee, property: convertExpression(expr), computed: true, optional: false };
+    }
+  }
+  return callee;
+}
+function convertMemberAccess(cst) {
+  let object = convertExpression(getFirstChild(cst, "primary"));
+  const dots = cst.children.Dot || [];
+  const questionDots = cst.children.QuestionDot || [];
+  const brackets = cst.children.LeftBracket || [];
+  const dotDotDots = cst.children.DotDotDot || [];
+  if (dots.length === 0 && questionDots.length === 0 && brackets.length === 0) {
+    return object;
+  }
+  const allOps = [];
+  for (const dot of dots) {
+    allOps.push({ type: "dot", token: dot, optional: false });
+  }
+  for (const qDot of questionDots) {
+    allOps.push({ type: "dot", token: qDot, optional: true });
+  }
+  allOps.sort((a, b) => a.token.startOffset - b.token.startOffset);
+  const identifiers = cst.children.Identifier || [];
+  let identifierIndex = 0;
+  for (let i = 0; i < allOps.length; i++) {
+    const op = allOps[i];
+    const identifier2 = identifiers[identifierIndex];
+    if (identifier2) {
+      identifierIndex++;
+      object = {
+        type: "memberAccess",
+        object,
+        property: identifier2.image,
+        computed: false,
+        optional: op.optional
+      };
+    }
+  }
+  const expressions = getAllChildren(cst, "expression");
+  let expressionIndex = 0;
+  for (let i = 0; i < brackets.length; i++) {
+    const bracket = brackets[i];
+    const bracketStart = bracket.startOffset;
+    const isOptional = questionDots.some((qDot) => {
+      return qDot.endOffset < bracketStart && bracketStart - qDot.endOffset <= 1;
+    });
+    const rightBrackets = cst.children.RightBracket || [];
+    const rightBracket = rightBrackets[i];
+    if (!rightBracket) continue;
+    const dotDotDotsInRange = dotDotDots.filter(
+      (ddd) => ddd.startOffset > bracketStart && ddd.startOffset < rightBracket.startOffset
+    );
+    if (dotDotDotsInRange.length > 0) {
+      if (expressions.length === expressionIndex) {
+        object = {
+          type: "arraySlice",
+          object,
+          start: null,
+          end: null
+        };
+        continue;
+      }
+      if (expressions.length >= expressionIndex + 2) {
+        const startExpr = expressions[expressionIndex];
+        const endExpr = expressions[expressionIndex + 1];
+        expressionIndex += 2;
+        object = {
+          type: "arraySlice",
+          object,
+          start: convertExpression(startExpr),
+          end: convertExpression(endExpr)
+        };
+        continue;
+      }
+      if (expressions.length === expressionIndex + 1) {
+        const startExpr = expressions[expressionIndex];
+        expressionIndex++;
+        object = {
+          type: "arraySlice",
+          object,
+          start: convertExpression(startExpr),
+          end: null
+        };
+        continue;
+      }
+    }
+    if (expressions.length > expressionIndex) {
+      const exprCst = expressions[expressionIndex];
+      expressionIndex++;
+      const property = convertExpression(exprCst);
+      object = {
+        type: "memberAccess",
+        object,
+        property,
+        computed: true,
+        optional: isOptional
+      };
+    }
+  }
+  return object;
+}
+function convertPrimary(cst) {
+  if (cst.children.literal) {
+    return convertLiteral(getFirstChild(cst, "literal"));
+  }
+  if (cst.children.arrayLiteral) {
+    return convertArrayLiteral(getFirstChild(cst, "arrayLiteral"));
+  }
+  if (cst.children.objectLiteral) {
+    return convertObjectLiteral(getFirstChild(cst, "objectLiteral"));
+  }
+  if (cst.children.arrowFunction) {
+    return convertArrowFunction(getFirstChild(cst, "arrowFunction"));
+  }
+  if (cst.children.jsxElement) {
+    return convertJSXElement(getFirstChild(cst, "jsxElement"));
+  }
+  if (cst.children.jsxFragment) {
+    return convertJSXFragment(getFirstChild(cst, "jsxFragment"));
+  }
+  if (cst.children.parenthesizedExpression) {
+    const parenCst = getFirstChild(cst, "parenthesizedExpression");
+    if (parenCst.children.Equal && parenCst.children.Equal.length > 0) {
+      const paramList = getFirstChild(parenCst, "parameterList");
+      let parameters = [];
+      if (paramList) {
+        parameters = convertParameterList(paramList);
+      } else {
+        parameters = [];
+      }
+      const blockStatementCST = getFirstChild(parenCst, "blockStatement");
+      const expressionCST = getFirstChild(parenCst, "expression");
+      let body;
+      if (blockStatementCST) {
+        body = {
+          type: "blockStatement",
+          body: getAllChildren(blockStatementCST, "statement").map(convertStatement)
+        };
+      } else if (expressionCST) {
+        body = convertExpression(expressionCST);
+      } else {
+        body = null;
+      }
+      return {
+        type: "arrowFunction",
+        parameters,
+        body
+      };
+    }
+    const exprCst = getFirstChild(parenCst, "expression");
+    return exprCst ? convertExpression(exprCst) : null;
+  }
+  if (cst.children.identifier) {
+    const id = getFirstChild(cst, "identifier");
+    return {
+      type: "identifier",
+      name: id.children.Identifier[0].image
+    };
+  }
+  return null;
+}
+function convertLiteral(cst) {
+  if (cst.children.NumberLiteral) {
+    const image = cst.children.NumberLiteral[0].image;
+    let value;
+    let raw = null;
+    if (image.startsWith("0x") || image.startsWith("0X")) {
+      value = parseInt(image, 16);
+      raw = image;
+    } else if (image.startsWith("0b") || image.startsWith("0B")) {
+      value = parseInt(image.slice(2), 2);
+      raw = image;
+    } else if (image.startsWith("0o") || image.startsWith("0O")) {
+      value = parseInt(image.slice(2), 8);
+      raw = image;
+    } else {
+      value = parseFloat(image);
+      if (image.includes("e") || image.includes("E") || image.includes(".")) {
+        raw = image;
+      }
+    }
+    return { type: "number", value, raw };
+  }
+  if (cst.children.StringLiteral) {
+    const image = cst.children.StringLiteral[0].image;
+    const value = image.slice(1, -1);
+    return { type: "string", value };
+  }
+  if (cst.children.templateLiteral) {
+    return convertTemplateLiteral(getFirstChild(cst, "templateLiteral"));
+  }
+  if (cst.children.True) {
+    return { type: "boolean", value: true };
+  }
+  if (cst.children.False) {
+    return { type: "boolean", value: false };
+  }
+  if (cst.children.Null) {
+    return { type: "null", value: null };
+  }
+  return null;
+}
+function convertTemplateLiteral(cst) {
+  var _a;
+  const token = (_a = cst.children.TemplateLiteral) == null ? void 0 : _a[0];
+  if (!token) return null;
+  return convertTemplateLiteralFromToken(token);
+}
+function convertTemplateLiteralFromToken(token) {
+  const templateText = token.image;
+  const quasis = [];
+  const expressions = [];
+  let text = templateText.slice(1, -1);
+  let pos = 0;
+  let currentQuasiRaw = "";
+  let currentQuasiCooked = "";
+  let escaped = false;
+  let braceDepth = 0;
+  while (pos < text.length) {
+    const char = text[pos];
+    if (escaped) {
+      currentQuasiRaw += "\\" + char;
+      if (char === "`") {
+        currentQuasiCooked += "`";
+      } else if (char === "$") {
+        currentQuasiCooked += "$";
+      } else if (char === "{") {
+        currentQuasiCooked += "{";
+      } else if (char === "}") {
+        currentQuasiCooked += "}";
+      } else if (char === "\\") {
+        currentQuasiCooked += "\\";
+      } else {
+        currentQuasiCooked += "\\" + char;
+      }
+      escaped = false;
+      pos++;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      pos++;
+      continue;
+    }
+    if (char === "$" && pos + 1 < text.length && text[pos + 1] === "{") {
+      quasis.push({
+        type: "templateElement",
+        value: { raw: currentQuasiRaw, cooked: currentQuasiCooked },
+        tail: false
+      });
+      currentQuasiRaw = "";
+      currentQuasiCooked = "";
+      pos += 2;
+      braceDepth = 1;
+      let exprStart = pos;
+      while (pos < text.length && braceDepth > 0) {
+        if (text[pos] === "{") {
+          braceDepth++;
+        } else if (text[pos] === "}") {
+          braceDepth--;
+          if (braceDepth === 0) {
+            const exprText = text.substring(exprStart, pos);
+            try {
+              const exprAST = parseOddoExpression(exprText);
+              expressions.push(exprAST);
+            } catch (e) {
+              expressions.push({
+                type: "error",
+                message: `Failed to parse expression: ${exprText}`
+              });
+            }
+            pos++;
+            break;
+          }
+        }
+        pos++;
+      }
+      continue;
+    }
+    currentQuasiRaw += char;
+    currentQuasiCooked += char;
+    pos++;
+  }
+  quasis.push({
+    type: "templateElement",
+    value: { raw: currentQuasiRaw, cooked: currentQuasiCooked },
+    tail: true
+  });
+  return {
+    type: "templateLiteral",
+    quasis,
+    expressions
+  };
+}
+function convertArrayLiteral(cst) {
+  const elements = [];
+  const elementList = getFirstChild(cst, "arrayElementList");
+  if (elementList) {
+    const expressions = getAllChildren(elementList, "expression");
+    const dotDotDots = elementList.children.DotDotDot || [];
+    for (let i = 0; i < expressions.length; i++) {
+      const exprCst = expressions[i];
+      const exprStart = getFirstTokenOffset(exprCst);
+      const isSpread = exprStart !== void 0 && dotDotDots.some((dot) => {
+        const dotEnd = dot.endOffset;
+        return Math.abs(dotEnd + 1 - exprStart) <= 1;
+      });
+      if (isSpread) {
+        elements.push({
+          type: "spread",
+          expression: convertExpression(exprCst)
+        });
+      } else {
+        elements.push(convertExpression(exprCst));
+      }
+    }
+  }
+  return {
+    type: "array",
+    elements
+  };
+}
+function convertObjectLiteral(cst) {
+  const properties = [];
+  const propertyList = getFirstChild(cst, "objectPropertyList");
+  if (propertyList) {
+    properties.push(...getAllChildren(propertyList, "objectProperty").map(convertObjectProperty));
+  }
+  return {
+    type: "object",
+    properties
+  };
+}
+function convertObjectProperty(cst) {
+  var _a, _b;
+  if (cst.children.DotDotDot && cst.children.DotDotDot.length > 0) {
+    const expression = convertExpression(getFirstChild(cst, "expression"));
+    return {
+      type: "spreadProperty",
+      argument: expression
+    };
+  }
+  if (cst.children.LeftBracket && cst.children.LeftBracket.length > 0) {
+    const expressions = getAllChildren(cst, "expression");
+    const keyExpression = expressions[0] ? convertExpression(expressions[0]) : null;
+    const valueExpression = expressions[1] ? convertExpression(expressions[1]) : null;
+    if (!keyExpression || !valueExpression) {
+      throw new Error("Computed key property must have both key and value expressions");
+    }
+    return {
+      type: "property",
+      key: keyExpression,
+      value: valueExpression,
+      shorthand: false,
+      computed: true
+    };
+  }
+  const identifier2 = (_a = cst.children.Identifier) == null ? void 0 : _a[0];
+  const stringLiteral2 = (_b = cst.children.StringLiteral) == null ? void 0 : _b[0];
+  const hasColon = cst.children.Colon && cst.children.Colon.length > 0;
+  if (hasColon) {
+    const key = identifier2 ? { type: "identifier", name: identifier2.image } : stringLiteral2 ? { type: "string", value: stringLiteral2.image.slice(1, -1) } : null;
+    const value = convertExpression(getFirstChild(cst, "expression"));
+    return {
+      type: "property",
+      key,
+      value,
+      shorthand: false,
+      computed: false
+    };
+  } else {
+    if (!identifier2) {
+      return null;
+    }
+    const name = identifier2.image;
+    return {
+      type: "property",
+      key: { type: "identifier", name },
+      value: { type: "identifier", name },
+      shorthand: true,
+      computed: false
+    };
+  }
+}
+function convertArrowFunction(cst) {
+  let parameters = [];
+  if (cst.children.Identifier && cst.children.Identifier.length === 1 && !cst.children.LeftParen) {
+    parameters = [{
+      type: "parameter",
+      name: cst.children.Identifier[0].image
+    }];
+  } else if (cst.children.arrowFunctionParams) {
+    const paramsCST = getFirstChild(cst, "arrowFunctionParams");
+    if (paramsCST && paramsCST.children.Identifier && paramsCST.children.Identifier.length === 1 && !paramsCST.children.LeftParen) {
+      parameters = [{
+        type: "parameter",
+        name: paramsCST.children.Identifier[0].image
+      }];
+    } else if (paramsCST) {
+      const paramList = getFirstChild(paramsCST, "parameterList");
+      if (paramList) {
+        parameters = convertParameterList(paramList);
+      }
+    }
+  } else if (cst.children.LeftParen) {
+    const paramList = getFirstChild(cst, "parameterList");
+    if (paramList) {
+      parameters = convertParameterList(paramList);
+    }
+  }
+  const blockStatementCST = getFirstChild(cst, "blockStatement");
+  const expressionCST = getFirstChild(cst, "expression");
+  let body;
+  if (blockStatementCST) {
+    body = {
+      type: "blockStatement",
+      body: getAllChildren(blockStatementCST, "statement").map(convertStatement)
+    };
+  } else if (expressionCST) {
+    body = convertExpression(expressionCST);
+  } else {
+    body = null;
+  }
+  return {
+    type: "arrowFunction",
+    parameters,
+    body
+  };
+}
+function convertParameterList(cst) {
+  var _a, _b, _c, _d;
+  if (!cst) return [];
+  const parameters = [];
+  const identifiers = cst.children.Identifier || [];
+  const dotDotDots = cst.children.DotDotDot || [];
+  const equals = cst.children.Equal || [];
+  const destructuringPatterns = getAllChildren(cst, "destructuringPattern");
+  const commas = cst.children.Comma || [];
+  const expressions = cst.children.expression || [];
+  const getExprStart = (expr) => {
+    var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia, _ja, _ka, _la, _ma, _na, _oa;
+    if (!expr) return null;
+    if (expr.startOffset) return expr.startOffset;
+    const numberLit = (_e = (_d2 = (_c2 = (_b2 = (_a2 = expr.children) == null ? void 0 : _a2.number) == null ? void 0 : _b2[0]) == null ? void 0 : _c2.children) == null ? void 0 : _d2.NumberLiteral) == null ? void 0 : _e[0];
+    if (numberLit == null ? void 0 : numberLit.startOffset) return numberLit.startOffset;
+    const identifier2 = (_j = (_i = (_h = (_g = (_f = expr.children) == null ? void 0 : _f.identifier) == null ? void 0 : _g[0]) == null ? void 0 : _h.children) == null ? void 0 : _i.Identifier) == null ? void 0 : _j[0];
+    if (identifier2 == null ? void 0 : identifier2.startOffset) return identifier2.startOffset;
+    const literal = (_l = (_k = expr.children) == null ? void 0 : _k.literal) == null ? void 0 : _l[0];
+    if (literal) {
+      const litNumber = (_n = (_m = literal.children) == null ? void 0 : _m.NumberLiteral) == null ? void 0 : _n[0];
+      if (litNumber == null ? void 0 : litNumber.startOffset) return litNumber.startOffset;
+    }
+    const assignment = (_p = (_o = expr.children) == null ? void 0 : _o.assignment) == null ? void 0 : _p[0];
+    if (assignment) {
+      const nestedId = (_oa = (_na = (_ma = (_la = (_ka = (_ja = (_ia = (_ha = (_ga = (_fa = (_ea = (_da = (_ca = (_ba = (_aa = (_$ = (__ = (_Z = (_Y = (_X = (_W = (_V = (_U = (_T = (_S = (_R = (_Q = (_P = (_O = (_N = (_M = (_L = (_K = (_J = (_I = (_H = (_G = (_F = (_E = (_D = (_C = (_B = (_A = (_z = (_y = (_x = (_w = (_v = (_u = (_t = (_s = (_r = (_q = assignment.children) == null ? void 0 : _q.conditional) == null ? void 0 : _r[0]) == null ? void 0 : _s.children) == null ? void 0 : _t.logicalOr) == null ? void 0 : _u[0]) == null ? void 0 : _v.children) == null ? void 0 : _w.pipe) == null ? void 0 : _x[0]) == null ? void 0 : _y.children) == null ? void 0 : _z.compose) == null ? void 0 : _A[0]) == null ? void 0 : _B.children) == null ? void 0 : _C.nullishCoalescing) == null ? void 0 : _D[0]) == null ? void 0 : _E.children) == null ? void 0 : _F.logicalAnd) == null ? void 0 : _G[0]) == null ? void 0 : _H.children) == null ? void 0 : _I.equality) == null ? void 0 : _J[0]) == null ? void 0 : _K.children) == null ? void 0 : _L.relational) == null ? void 0 : _M[0]) == null ? void 0 : _N.children) == null ? void 0 : _O.additive) == null ? void 0 : _P[0]) == null ? void 0 : _Q.children) == null ? void 0 : _R.multiplicative) == null ? void 0 : _S[0]) == null ? void 0 : _T.children) == null ? void 0 : _U.exponentiation) == null ? void 0 : _V[0]) == null ? void 0 : _W.children) == null ? void 0 : _X.unary) == null ? void 0 : _Y[0]) == null ? void 0 : _Z.children) == null ? void 0 : __.postfix) == null ? void 0 : _$[0]) == null ? void 0 : _aa.children) == null ? void 0 : _ba.functionCall) == null ? void 0 : _ca[0]) == null ? void 0 : _da.children) == null ? void 0 : _ea.memberAccess) == null ? void 0 : _fa[0]) == null ? void 0 : _ga.children) == null ? void 0 : _ha.primary) == null ? void 0 : _ia[0]) == null ? void 0 : _ja.children) == null ? void 0 : _ka.identifier) == null ? void 0 : _la[0]) == null ? void 0 : _ma.children) == null ? void 0 : _na.Identifier) == null ? void 0 : _oa[0];
+      if (nestedId == null ? void 0 : nestedId.startOffset) return nestedId.startOffset;
+    }
+    return null;
+  };
+  const paramCandidates = [];
+  for (const dotDotDot of dotDotDots) {
+    const restId = identifiers.find((id) => id.startOffset > dotDotDot.startOffset);
+    if (restId) {
+      paramCandidates.push({
+        type: "rest",
+        start: dotDotDot.startOffset,
+        id: restId
+      });
+    }
+  }
+  for (const pattern of destructuringPatterns) {
+    const leftBracket = (_b = (_a = pattern.children) == null ? void 0 : _a.LeftBracket) == null ? void 0 : _b[0];
+    const leftBrace = (_d = (_c = pattern.children) == null ? void 0 : _c.LeftBrace) == null ? void 0 : _d[0];
+    const patternStart = (leftBracket == null ? void 0 : leftBracket.startOffset) || (leftBrace == null ? void 0 : leftBrace.startOffset) || pattern.startOffset || 0;
+    paramCandidates.push({
+      type: "destructuring",
+      start: patternStart,
+      pattern
+    });
+  }
+  for (const id of identifiers) {
+    const isRestId = dotDotDots.some((dot) => {
+      const dotEnd = dot.endOffset || dot.startOffset + 3;
+      return id.startOffset > dot.startOffset && id.startOffset < dotEnd + 5;
+    });
+    const isInPattern = destructuringPatterns.some((pattern) => {
+      var _a2, _b2, _c2, _d2;
+      const patternStart = pattern.startOffset;
+      let patternEnd = pattern.endOffset;
+      if (!patternEnd) {
+        const rightBracket = (_b2 = (_a2 = pattern.children) == null ? void 0 : _a2.RightBracket) == null ? void 0 : _b2[0];
+        const rightBrace = (_d2 = (_c2 = pattern.children) == null ? void 0 : _c2.RightBrace) == null ? void 0 : _d2[0];
+        patternEnd = (rightBracket == null ? void 0 : rightBracket.endOffset) || (rightBrace == null ? void 0 : rightBrace.endOffset) || patternStart + 1e3;
+      }
+      return id.startOffset >= patternStart && id.startOffset <= patternEnd;
+    });
+    if (!isRestId && !isInPattern) {
+      paramCandidates.push({
+        type: "identifier",
+        start: id.startOffset,
+        id
+      });
+    }
+  }
+  paramCandidates.sort((a, b) => a.start - b.start);
+  let exprIndex = 0;
+  for (let i = 0; i < paramCandidates.length; i++) {
+    const candidate = paramCandidates[i];
+    const nextComma = commas.find((c) => c.startOffset > candidate.start);
+    const nextCommaStart = nextComma ? nextComma.startOffset : Infinity;
+    const nextCandidate = i < paramCandidates.length - 1 ? paramCandidates[i + 1] : null;
+    const nextCandidateStart = nextCandidate ? nextCandidate.start : Infinity;
+    const boundary = Math.min(nextCommaStart, nextCandidateStart);
+    if (candidate.type === "rest") {
+      parameters.push({
+        type: "restElement",
+        argument: {
+          type: "identifier",
+          name: candidate.id.image
+        }
+      });
+      break;
+    } else if (candidate.type === "destructuring") {
+      const patternAST = convertDestructuringPattern(candidate.pattern);
+      const patternEnd = candidate.pattern.endOffset || candidate.pattern.startOffset + 100;
+      const patternEqual = equals.find(
+        (eq) => eq.startOffset > patternEnd && eq.startOffset < boundary
+      );
+      let defaultValue = null;
+      if (patternEqual && exprIndex < expressions.length) {
+        defaultValue = convertExpression(expressions[exprIndex]);
+        exprIndex++;
+      }
+      parameters.push({
+        type: "destructuringPattern",
+        pattern: patternAST,
+        default: defaultValue
+      });
+    } else if (candidate.type === "identifier") {
+      const id = candidate.id;
+      const idEnd = id.endOffset || id.startOffset + id.image.length;
+      const paramEqual = equals.find(
+        (eq) => eq.startOffset > idEnd && eq.startOffset < boundary
+      );
+      let defaultValue = null;
+      if (paramEqual && exprIndex < expressions.length) {
+        defaultValue = convertExpression(expressions[exprIndex]);
+        exprIndex++;
+      }
+      parameters.push({
+        type: "parameter",
+        name: id.image,
+        default: defaultValue
+      });
+    }
+  }
+  return parameters;
+}
+function convertJSXElement(cst) {
+  const nameCST = getFirstChild(cst, "jsxElementName");
+  const identifiers = nameCST.children.Identifier || [];
+  const dots = nameCST.children.Dot || [];
+  const minuses = nameCST.children.Minus || [];
+  const tokens = [];
+  identifiers.forEach((id) => tokens.push({ type: "id", token: id }));
+  dots.forEach((dot) => tokens.push({ type: "dot", token: dot }));
+  minuses.forEach((minus) => tokens.push({ type: "minus", token: minus }));
+  tokens.sort((a, b) => a.token.startOffset - b.token.startOffset);
+  let name = "";
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.type === "id") {
+      if (name) {
+        const prevToken = tokens[i - 1];
+        if (prevToken && prevToken.type === "dot") {
+          name += ".";
+        } else if (prevToken && prevToken.type === "minus") {
+          name += "-";
+        }
+      }
+      name += token.token.image;
+    }
+  }
+  const attributes = getAllChildren(cst, "jsxAttribute").map(convertJSXAttribute);
+  const isSelfClosing = cst.children.JSXSelfClosing && cst.children.JSXSelfClosing.length > 0;
+  let children = [];
+  if (!isSelfClosing) {
+    children = getAllChildren(cst, "jsxChild").map(convertJSXChild).filter((child) => child !== null);
+  }
+  return {
+    type: "jsxElement",
+    name,
+    attributes,
+    children,
+    selfClosing: isSelfClosing || false
+    // Explicitly set to false for non-self-closing elements
+  };
+}
+function convertJSXFragment(cst) {
+  const childrenCST = getAllChildren(cst, "jsxChild");
+  const children = childrenCST.map(convertJSXChild).filter((child) => child !== null);
+  return {
+    type: "jsxFragment",
+    children
+  };
+}
+function convertJSXAttribute(cst) {
+  var _a;
+  if (cst.children.LeftBrace) {
+    const expression = convertExpression(getFirstChild(cst, "expression"));
+    return {
+      type: "jsxSpread",
+      expression
+    };
+  } else {
+    const identifiers = cst.children.Identifier || [];
+    const minuses = cst.children.Minus || [];
+    let name = ((_a = identifiers[0]) == null ? void 0 : _a.image) || "";
+    for (let i = 0; i < minuses.length && i + 1 < identifiers.length; i++) {
+      name += "-" + identifiers[i + 1].image;
+    }
+    const valueCST = getFirstChild(cst, "jsxAttributeValue");
+    let value = { type: "boolean", value: true };
+    if (valueCST) {
+      if (valueCST.children.StringLiteral) {
+        const image = valueCST.children.StringLiteral[0].image;
+        value = { type: "string", value: image.slice(1, -1) };
+      } else if (valueCST.children.LeftBrace) {
+        const expr = convertExpression(getFirstChild(valueCST, "expression"));
+        value = { type: "expression", value: expr };
+      }
+    }
+    return {
+      type: "jsxAttribute",
+      name,
+      value
+    };
+  }
+}
+function decodeHTMLEntities(text) {
+  const entities = {
+    "nbsp": "\xA0",
+    // non-breaking space
+    "lt": "<",
+    "gt": ">",
+    "amp": "&",
+    "quot": '"',
+    "apos": "'",
+    "cent": "\xA2",
+    // ¢
+    "pound": "\xA3",
+    // £
+    "yen": "\xA5",
+    // ¥
+    "euro": "\u20AC",
+    // €
+    "copy": "\xA9",
+    // ©
+    "reg": "\xAE",
+    // ®
+    "trade": "\u2122",
+    // ™
+    "mdash": "\u2014",
+    // —
+    "ndash": "\u2013",
+    // –
+    "hellip": "\u2026",
+    // …
+    "laquo": "\xAB",
+    // «
+    "raquo": "\xBB",
+    // »
+    "ldquo": "\u201C",
+    // "
+    "rdquo": "\u201D",
+    // "
+    "lsquo": "\u2018",
+    // '
+    "rsquo": "\u2019",
+    // '
+    "bull": "\u2022",
+    // •
+    "deg": "\xB0",
+    // °
+    "plusmn": "\xB1",
+    // ±
+    "times": "\xD7",
+    // ×
+    "divide": "\xF7",
+    // ÷
+    "ne": "\u2260",
+    // ≠
+    "le": "\u2264",
+    // ≤
+    "ge": "\u2265",
+    // ≥
+    "infin": "\u221E",
+    // ∞
+    "sum": "\u2211",
+    // ∑
+    "prod": "\u220F",
+    // ∏
+    "larr": "\u2190",
+    // ←
+    "uarr": "\u2191",
+    // ↑
+    "rarr": "\u2192",
+    // →
+    "darr": "\u2193",
+    // ↓
+    "harr": "\u2194"
+    // ↔
+  };
+  return text.replace(/&([a-zA-Z]+|#\d+|#x[0-9a-fA-F]+);/g, (match, entity) => {
+    if (entity.startsWith("#x")) {
+      const code = parseInt(entity.substring(2), 16);
+      return String.fromCharCode(code);
+    } else if (entity.startsWith("#")) {
+      const code = parseInt(entity.substring(1), 10);
+      return String.fromCharCode(code);
+    } else {
+      return entities[entity] || match;
+    }
+  });
+}
+function convertJSXChild(cst) {
+  if (cst.children.jsxElement) {
+    return convertJSXElement(getFirstChild(cst, "jsxElement"));
+  }
+  if (cst.children.jsxFragment) {
+    return convertJSXFragment(getFirstChild(cst, "jsxFragment"));
+  }
+  if (cst.children.LeftBrace) {
+    const expressionCST = getFirstChild(cst, "expression");
+    if (!expressionCST) {
+      return null;
+    }
+    const expression = convertExpression(expressionCST);
+    return {
+      type: "jsxExpression",
+      expression
+    };
+  }
+  const allTokens2 = [];
+  for (const key in cst.children) {
+    if (key === "jsxElement" || key === "LeftBrace") {
+      continue;
+    }
+    if (cst.children[key] && Array.isArray(cst.children[key])) {
+      cst.children[key].forEach((token) => {
+        if (token && token.image !== void 0) {
+          allTokens2.push({ token, offset: token.startOffset });
+        }
+      });
+    }
+  }
+  if (allTokens2.length > 0) {
+    allTokens2.sort((a, b) => a.offset - b.offset);
+    let textValue = "";
+    for (let i = 0; i < allTokens2.length; i++) {
+      const current = allTokens2[i];
+      if (i > 0) {
+        const previous = allTokens2[i - 1];
+        const previousEnd = previous.token.endOffset !== void 0 ? previous.token.endOffset : previous.token.startOffset + previous.token.image.length - 1;
+        if (current.token.startOffset > previousEnd + 1) {
+          textValue += " ";
+        }
+      }
+      textValue += current.token.image;
+    }
+    const decodedValue = decodeHTMLEntities(textValue);
+    return {
+      type: "jsxText",
+      value: decodedValue
+    };
+  }
+  return null;
+}
+function convertCSTToAST(cst) {
+  if (!cst) return null;
+  if (cst.name === "program") {
+    const statements = getAllChildren(cst, "statement").map(convertStatement);
+    return {
+      type: "program",
+      body: statements
+    };
+  }
+  return null;
+}
+
+// src/compiler.mjs
+var _generator = require('@babel/generator'); var _generator2 = _interopRequireDefault(_generator);
+var _traverse2 = require('@babel/traverse'); var _traverse3 = _interopRequireDefault(_traverse2);
+var _types = require('@babel/types'); var t = _interopRequireWildcard(_types);
+var generate = _generator2.default.default || _generator2.default;
+var traverse = _traverse3.default.default || _traverse3.default;
+function extractIdentifiers(babelNode) {
+  const identifiers = /* @__PURE__ */ new Set();
+  const locals = /* @__PURE__ */ new Set();
+  function traverse2(node) {
+    var _a, _b, _c;
+    if (!node) return;
+    if (t.isIdentifier(node)) {
+      if (!locals.has(node.name) && !node.name.startsWith("__ODDO_IMPORT_")) {
+        identifiers.add(node.name);
+      }
+    } else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+      traverse2(node.object);
+      if (node.computed) traverse2(node.property);
+    } else if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+      traverse2(node.callee);
+      (_a = node.arguments) == null ? void 0 : _a.forEach((arg) => traverse2(arg));
+    } else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) {
+      traverse2(node.left);
+      traverse2(node.right);
+    } else if (t.isUnaryExpression(node)) {
+      traverse2(node.argument);
+    } else if (t.isConditionalExpression(node)) {
+      traverse2(node.test);
+      traverse2(node.consequent);
+      traverse2(node.alternate);
+    } else if (t.isArrayExpression(node)) {
+      (_b = node.elements) == null ? void 0 : _b.forEach((el) => traverse2(el));
+    } else if (t.isObjectExpression(node)) {
+      (_c = node.properties) == null ? void 0 : _c.forEach((prop) => {
+        if (t.isObjectProperty(prop)) {
+          if (prop.computed) traverse2(prop.key);
+          traverse2(prop.value);
+        } else if (t.isSpreadElement(prop)) {
+          traverse2(prop.argument);
+        }
+      });
+    } else if (t.isArrowFunctionExpression(node)) {
+      node.params.forEach((p) => {
+        var _a2;
+        if (t.isIdentifier(p)) locals.add(p.name);
+        else if (t.isObjectPattern(p)) p.properties.forEach((prop) => t.isIdentifier(prop.value) && locals.add(prop.value.name));
+        else if (t.isArrayPattern(p)) (_a2 = p.elements) == null ? void 0 : _a2.forEach((el) => t.isIdentifier(el) && locals.add(el.name));
+      });
+      if (t.isBlockStatement(node.body)) node.body.body.forEach((s) => traverse2(s));
+      else traverse2(node.body);
+    } else if (t.isBlockStatement(node)) {
+      node.body.forEach((s) => traverse2(s));
+    } else if (t.isExpressionStatement(node)) {
+      traverse2(node.expression);
+    } else if (t.isReturnStatement(node)) {
+      traverse2(node.argument);
+    } else if (t.isSequenceExpression(node)) {
+      node.expressions.forEach((expr) => traverse2(expr));
+    } else if (t.isUpdateExpression(node)) {
+      traverse2(node.argument);
+    } else if (t.isAssignmentExpression(node)) {
+      traverse2(node.left);
+      traverse2(node.right);
+    } else if (t.isSpreadElement(node)) {
+      traverse2(node.argument);
+    }
+  }
+  traverse2(babelNode);
+  return Array.from(identifiers);
+}
+function wrapDependenciesWithCalls(arrowFunc, deps) {
+  const depSet = new Set(deps);
+  const locals = /* @__PURE__ */ new Set();
+  const tempFile = t.file(t.program([t.expressionStatement(arrowFunc)]));
+  traverse(tempFile, {
+    noScope: true,
+    ArrowFunctionExpression(path) {
+      if (path.node !== arrowFunc) {
+        path.node.params.forEach((p) => t.isIdentifier(p) && locals.add(p.name));
+      }
+    }
+  });
+  const toReplace = [];
+  const shorthandToExpand = [];
+  traverse(tempFile, {
+    noScope: true,
+    Identifier(path) {
+      if (t.isArrowFunctionExpression(path.parent) && path.parent.params.includes(path.node)) {
+        return;
+      }
+      const parent = path.parent;
+      const isMemberProp = t.isMemberExpression(parent) && parent.property === path.node && !parent.computed;
+      const isObjectKey = t.isObjectProperty(parent) && parent.key === path.node && !parent.shorthand;
+      const isShorthand = t.isObjectProperty(parent) && parent.shorthand && parent.key === path.node;
+      if (depSet.has(path.node.name) && !isMemberProp && !isObjectKey && !locals.has(path.node.name)) {
+        if (isShorthand) {
+          shorthandToExpand.push({ prop: parent, name: path.node.name });
+        } else {
+          toReplace.push(path);
+        }
+      }
+    }
+  });
+  shorthandToExpand.forEach(({ prop, name }) => {
+    prop.shorthand = false;
+    prop.value = t.callExpression(t.identifier(name), []);
+  });
+  toReplace.forEach((p) => p.replaceWith(t.callExpression(t.identifier(p.node.name), [])));
+}
+function getReactiveDeps(identifiers) {
+  return identifiers.filter((id) => {
+    if (!isDeclared(id)) {
+      return false;
+    }
+    if (isNonReactive(id)) {
+      return false;
+    }
+    return true;
+  });
+}
+function createLiftedExpr(valueExpr, identifiers) {
+  const reactiveDeps = getReactiveDeps(identifiers);
+  if (reactiveDeps.length === 0) {
+    return null;
+  }
+  const depParams = reactiveDeps.map((id) => t.identifier(id));
+  const depsArray = reactiveDeps.map((id) => t.identifier(id));
+  if (t.isArrowFunctionExpression(valueExpr)) {
+    usedModifiers.add("liftFn");
+    const newParams = [...depParams, ...valueExpr.params];
+    const liftedFunc = t.arrowFunctionExpression(newParams, valueExpr.body);
+    return t.callExpression(
+      t.identifier(modifierAliases["liftFn"]),
+      [liftedFunc, t.arrayExpression(depsArray)]
+    );
+  }
+  usedModifiers.add("lift");
+  const arrowFunc = t.arrowFunctionExpression(depParams, valueExpr);
+  return t.callExpression(
+    t.identifier(modifierAliases["lift"]),
+    [arrowFunc, t.arrayExpression(depsArray)]
+  );
+}
+function createReactiveExpr(valueExpr, attrExpression = false) {
+  const identifiers = extractIdentifiers(valueExpr);
+  const pragma = attrExpression ? "computed" : "x";
+  if (identifiers.length === 0) {
+    if (t.isLiteral(valueExpr)) {
+      return valueExpr;
+    }
+    usedModifiers.add(pragma);
+    const arrowFunc2 = t.arrowFunctionExpression([], valueExpr);
+    return t.callExpression(
+      t.identifier(modifierAliases[pragma]),
+      [arrowFunc2, t.arrayExpression([])]
+    );
+  }
+  usedModifiers.add(pragma);
+  const params = identifiers.map((id) => t.identifier(id));
+  const deps = identifiers.map((id) => t.identifier(id));
+  const arrowFunc = t.arrowFunctionExpression(params, valueExpr);
+  wrapDependenciesWithCalls(arrowFunc, identifiers);
+  return t.callExpression(
+    t.identifier(modifierAliases[pragma]),
+    [arrowFunc, t.arrayExpression(deps)]
+  );
+}
+var MODIFIER_TRANSFORMATIONS = {
+  state: {
+    needsImport: true,
+    // @state x = 3 -> const [x, setX] = _state(3);
+    transform: (valueExpr, leftExpr) => {
+      const stateCall = t.callExpression(
+        t.identifier(modifierAliases["state"]),
+        [valueExpr]
+      );
+      if (leftExpr && t.isIdentifier(leftExpr)) {
+        const getterName = leftExpr.name;
+        const setterBaseName = "set" + getterName.charAt(0).toUpperCase() + getterName.slice(1);
+        const setterName = generateUniqueId(setterBaseName);
+        stateSetterMap.set(getterName, setterName);
+        return t.variableDeclaration("const", [
+          t.variableDeclarator(
+            t.arrayPattern([
+              t.identifier(getterName),
+              t.identifier(setterName)
+            ]),
+            stateCall
+          )
+        ]);
+      }
+      return t.expressionStatement(stateCall);
+    }
+  },
+  computed: {
+    needsImport: true,
+    // @computed sum = x + y -> const sum = _computed((x, y) => x() + y(), [x, y])
+    transform: (valueExpr, leftExpr) => {
+      const identifiers = extractIdentifiers(valueExpr);
+      const params = identifiers.map((id) => t.identifier(id));
+      const deps = identifiers.map((id) => t.identifier(id));
+      const arrowFunc = t.arrowFunctionExpression(params, valueExpr);
+      wrapDependenciesWithCalls(arrowFunc, identifiers);
+      const computedCall = t.callExpression(
+        t.identifier(modifierAliases["computed"]),
+        [arrowFunc, t.arrayExpression(deps)]
+      );
+      if (leftExpr && t.isIdentifier(leftExpr)) {
+        return t.variableDeclaration("const", [
+          t.variableDeclarator(leftExpr, computedCall)
+        ]);
+      }
+      return t.expressionStatement(computedCall);
+    }
+  },
+  react: {
+    needsImport: true,
+    // @react sum = x + y -> const sum = _react((x, y) => x() + y(), [x, y])
+    transform: (valueExpr, leftExpr) => {
+      const identifiers = extractIdentifiers(valueExpr);
+      const params = identifiers.map((id) => t.identifier(id));
+      const deps = identifiers.map((id) => t.identifier(id));
+      const arrowFunc = t.arrowFunctionExpression(params, valueExpr);
+      wrapDependenciesWithCalls(arrowFunc, identifiers);
+      const reactCall = t.callExpression(
+        t.identifier(modifierAliases["react"]),
+        [arrowFunc, t.arrayExpression(deps)]
+      );
+      if (leftExpr) {
+        return t.variableDeclaration("const", [
+          t.variableDeclarator(leftExpr, reactCall)
+        ]);
+      }
+      return t.expressionStatement(reactCall);
+    }
+  },
+  mutate: {
+    needsImport: true,
+    // @mutate x = (arg1, arg2) => { x1 := value1; x2 := value2 }
+    // -> const x = mutate((finalizer, x1, x2, ...outerDeps, arg1, arg2) => { ... }, finalizerFn, stateContainers, outerDeps)
+    transform: (oddoExpr, leftExpr) => {
+      var _a, _b, _c, _d;
+      if (oddoExpr.type !== "arrowFunction") {
+        throw new Error("@mutate modifier must be a function");
+      }
+      const funcParams = (oddoExpr.parameters || []).map((p) => p.name);
+      const assignments = [];
+      const bodyStatements = ((_a = oddoExpr.body) == null ? void 0 : _a.body) || [];
+      for (const stmt of bodyStatements) {
+        if (stmt.type === "expressionStatement" && ((_b = stmt.expression) == null ? void 0 : _b.type) === "assignment" && ((_c = stmt.expression) == null ? void 0 : _c.operator) === ":=") {
+          const leftName = (_d = stmt.expression.left) == null ? void 0 : _d.name;
+          if (!leftName) {
+            throw new Error("@mutate: := assignment must have an identifier on the left side");
+          }
+          if (stateSetterMap.has(leftName)) {
+            assignments.push({
+              name: leftName,
+              kind: "state",
+              setter: stateSetterMap.get(leftName),
+              rightOddo: stmt.expression.right
+            });
+          } else if (mutableVariables.has(leftName)) {
+            assignments.push({
+              name: leftName,
+              kind: "mutable",
+              rightOddo: stmt.expression.right
+            });
+          } else {
+            throw new Error(`@mutate: Cannot mutate '${leftName}': not a @state or @mutable variable in current scope`);
+          }
+        }
+      }
+      if (assignments.length === 0) {
+        throw new Error("@mutate function must contain at least one := assignment");
+      }
+      const stateAssignments = assignments.filter((a) => a.kind === "state");
+      const mutableAssignments = assignments.filter((a) => a.kind === "mutable");
+      const stateContainerNames = stateAssignments.map((a) => a.name);
+      const allAssignmentNames = assignments.map((a) => a.name);
+      const outerDeps = /* @__PURE__ */ new Set();
+      for (const assignment of assignments) {
+        collectOddoIdentifiers(assignment.rightOddo).forEach((id) => {
+          if (!funcParams.includes(id) && !allAssignmentNames.includes(id)) {
+            outerDeps.add(id);
+          }
+        });
+      }
+      const outerDepsArray = Array.from(outerDeps);
+      const mutateParams = [
+        t.identifier("finalizer"),
+        ...stateContainerNames.map((n) => t.identifier(n)),
+        ...outerDepsArray.map((n) => t.identifier(n)),
+        ...funcParams.map((n) => t.identifier(n))
+      ];
+      const mutateBodyStmts = [];
+      if (stateAssignments.length > 0) {
+        usedModifiers.add("stateProxy");
+      }
+      const callableIds = /* @__PURE__ */ new Set([
+        ...stateContainerNames,
+        ...outerDepsArray.filter((id) => !mutableVariables.has(id))
+      ]);
+      for (const assignment of assignments) {
+        const rightBabel = convertExpression2(assignment.rightOddo);
+        const tempFile = t.file(t.program([t.expressionStatement(rightBabel)]));
+        const toReplace = [];
+        const shorthandToExpand = [];
+        traverse(tempFile, {
+          noScope: true,
+          Identifier(path) {
+            const parent = path.parent;
+            const isMemberProp = t.isMemberExpression(parent) && parent.property === path.node && !parent.computed;
+            const isObjectKey = t.isObjectProperty(parent) && parent.key === path.node && !parent.shorthand;
+            const isShorthand = t.isObjectProperty(parent) && parent.shorthand && parent.key === path.node;
+            if (callableIds.has(path.node.name) && !isMemberProp && !isObjectKey) {
+              if (isShorthand) {
+                shorthandToExpand.push({ prop: parent, name: path.node.name });
+              } else {
+                toReplace.push(path);
+              }
+            }
+          }
+        });
+        shorthandToExpand.forEach(({ prop, name }) => {
+          prop.shorthand = false;
+          prop.value = t.callExpression(t.identifier(name), []);
+        });
+        toReplace.forEach((p) => p.replaceWith(t.callExpression(t.identifier(p.node.name), [])));
+        const wrappedRightExpr = tempFile.program.body[0].expression;
+        if (assignment.kind === "state") {
+          mutateBodyStmts.push(
+            t.expressionStatement(
+              t.assignmentExpression(
+                "=",
+                t.identifier(assignment.name),
+                t.callExpression(
+                  t.identifier(modifierAliases["stateProxy"]),
+                  [wrappedRightExpr]
+                )
+              )
+            )
+          );
+        } else {
+          mutateBodyStmts.push(
+            t.expressionStatement(
+              t.assignmentExpression(
+                "=",
+                t.identifier(assignment.name),
+                wrappedRightExpr
+              )
+            )
+          );
+        }
+      }
+      if (stateContainerNames.length > 0) {
+        mutateBodyStmts.push(
+          t.expressionStatement(
+            t.callExpression(
+              t.identifier("finalizer"),
+              stateContainerNames.map((n) => t.callExpression(t.identifier(n), []))
+            )
+          )
+        );
+      }
+      const mutateArrowFunc = t.arrowFunctionExpression(
+        mutateParams,
+        t.blockStatement(mutateBodyStmts)
+      );
+      const finalizerParams = stateContainerNames.map((n) => t.identifier(n));
+      const finalizerCalls = stateAssignments.map(
+        (a) => t.callExpression(t.identifier(a.setter), [t.identifier(a.name)])
+      );
+      const finalizerBody = finalizerCalls.length === 0 ? t.identifier("undefined") : finalizerCalls.length === 1 ? finalizerCalls[0] : t.sequenceExpression(finalizerCalls);
+      const finalizerFunc = t.arrowFunctionExpression(finalizerParams, finalizerBody);
+      const stateContainersArray = t.arrayExpression(
+        stateContainerNames.map((n) => t.identifier(n))
+      );
+      const outerDepsArrayExpr = t.arrayExpression(
+        outerDepsArray.map((n) => t.identifier(n))
+      );
+      const mutateCall = t.callExpression(
+        t.identifier(modifierAliases["mutate"]),
+        [mutateArrowFunc, finalizerFunc, stateContainersArray, outerDepsArrayExpr]
+      );
+      if (leftExpr) {
+        return t.variableDeclaration("const", [
+          t.variableDeclarator(leftExpr, mutateCall)
+        ]);
+      }
+      return t.expressionStatement(mutateCall);
+    }
+  },
+  effect: {
+    needsImport: true,
+    // @effect (() => setWhatever(x)) -> _effect((setWhatever, x) => { setWhatever()(x()) }, [setWhatever, x])
+    // Note: receives Oddo AST (not Babel AST) to avoid premature wrapping with _liftFn
+    transform: (oddoExpr) => {
+      if (oddoExpr.type !== "arrowFunction") {
+        throw new Error("effect modifier must be a function");
+      }
+      const bodyIdentifiers = collectOddoIdentifiersOnly(oddoExpr.body);
+      const ownParams = new Set((oddoExpr.parameters || []).map((p) => p.name));
+      const identifiers = bodyIdentifiers.filter((id) => !ownParams.has(id) && isReactive(id));
+      const params = identifiers.map((id) => t.identifier(id));
+      const deps = identifiers.map((id) => t.identifier(id));
+      let convertedBody;
+      if (oddoExpr.body && oddoExpr.body.type === "blockStatement") {
+        const statements = oddoExpr.body.body.map((stmt) => convertStatement2(stmt));
+        convertedBody = t.blockStatement(statements);
+      } else if (oddoExpr.body) {
+        const exprBody = convertExpression2(oddoExpr.body);
+        convertedBody = t.blockStatement([t.expressionStatement(exprBody)]);
+      } else {
+        convertedBody = t.blockStatement([]);
+      }
+      const arrowFunc = t.arrowFunctionExpression(params, convertedBody);
+      wrapDependenciesWithCalls(arrowFunc, identifiers);
+      const effectCall = t.callExpression(
+        t.identifier(modifierAliases["effect"]),
+        [arrowFunc, t.arrayExpression(deps)]
+      );
+      return t.expressionStatement(effectCall);
+    }
+  },
+  mutable: {
+    needsImport: false,
+    // @mutable x = 3 -> let x = 3;
+    // @mutable x = y + 1 (y is @state) -> let x = _lift((y) => y() + 1, [y])
+    transform: (valueExpr, leftExpr) => {
+      if (leftExpr && t.isIdentifier(leftExpr)) {
+        mutableVariables.add(leftExpr.name);
+        const identifiers = extractIdentifiers(valueExpr);
+        const liftedExpr = createLiftedExpr(valueExpr, identifiers);
+        return t.variableDeclaration("let", [
+          t.variableDeclarator(leftExpr, liftedExpr || valueExpr)
+        ]);
+      }
+      return t.expressionStatement(valueExpr);
+    }
+  }
+};
+var usedModifiers = /* @__PURE__ */ new Set();
+var modifierAliases = {};
+var usedNames = /* @__PURE__ */ new Set();
+var stateSetterMap = /* @__PURE__ */ new Map();
+var mutableVariables = /* @__PURE__ */ new Set();
+var moduleScope = null;
+var currentScope = null;
+function declareVariable(name, type) {
+  const reactive = type === "state" || type === "computed" || type === "param";
+  currentScope[name] = { type, reactive };
+}
+function isDeclared(name) {
+  return name in currentScope;
+}
+function isReactive(name) {
+  var _a;
+  return ((_a = currentScope[name]) == null ? void 0 : _a.reactive) === true;
+}
+function isNonReactive(name) {
+  var _a;
+  return ((_a = currentScope[name]) == null ? void 0 : _a.reactive) === false;
+}
+function generateUniqueId(baseName) {
+  let candidate = baseName;
+  let i = 2;
+  while (usedNames.has(candidate)) {
+    candidate = `${baseName}${i++}`;
+  }
+  usedNames.add(candidate);
+  return candidate;
+}
+function collectOddoIdentifiers(node, names = /* @__PURE__ */ new Set()) {
+  var _a, _b, _c;
+  if (!node || typeof node !== "object") return names;
+  if (node.type === "program") {
+    moduleScope = /* @__PURE__ */ Object.create(null);
+    currentScope = moduleScope;
+  }
+  if (node.type === "identifier") {
+    names.add(node.name);
+  }
+  if (node.type === "expressionStatement") {
+    const varName = (_b = (_a = node.expression) == null ? void 0 : _a.left) == null ? void 0 : _b.name;
+    if (varName) {
+      if (node.modifier === "state") {
+        declareVariable(varName, "state");
+      } else if (node.modifier === "computed") {
+        declareVariable(varName, "computed");
+      } else if (node.modifier === "mutable") {
+        declareVariable(varName, "mutable");
+      } else if (!node.modifier && ((_c = node.expression) == null ? void 0 : _c.type) === "variableDeclaration") {
+        declareVariable(varName, "immutable");
+      }
+    }
+  }
+  if (node.type === "arrowFunction") {
+    const parentScope = currentScope;
+    currentScope = Object.create(parentScope);
+    node._scope = currentScope;
+    if (node.parameters) {
+      for (const param of node.parameters) {
+        if (param.name) {
+          declareVariable(param.name, "param");
+        }
+      }
+    }
+    if (node.body) {
+      collectOddoIdentifiers(node.body, names);
+    }
+    currentScope = parentScope;
+    return names;
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "type") continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      val.forEach((item) => collectOddoIdentifiers(item, names));
+    } else if (val && typeof val === "object") {
+      collectOddoIdentifiers(val, names);
+    }
+  }
+  return names;
+}
+function compileToJS(ast, config = {}) {
+  if (!ast || ast.type !== "program") {
+    throw new Error("Expected a program AST node");
+  }
+  const runtimeLibrary = config.runtimeLibrary || "@oddo/ui";
+  usedModifiers = /* @__PURE__ */ new Set();
+  modifierAliases = {};
+  stateSetterMap = /* @__PURE__ */ new Map();
+  mutableVariables = /* @__PURE__ */ new Set();
+  moduleScope = null;
+  currentScope = null;
+  usedNames = collectOddoIdentifiers(ast);
+  const allImports = ["state", "computed", "react", "mutate", "effect", "stateProxy", "lift", "liftFn", "e", "c", "x", "f"];
+  for (const name of allImports) {
+    modifierAliases[name] = `__ODDO_IMPORT_${name}__`;
+  }
+  const babelAST = convertProgram(ast);
+  const fileAST = t.file(babelAST);
+  const generateUid = (name) => {
+    let candidate = `_${name}`;
+    let i = 1;
+    while (usedNames.has(candidate)) {
+      candidate = `_${name}${i++}`;
+    }
+    usedNames.add(candidate);
+    return candidate;
+  };
+  const tempToUnique = {};
+  for (const name of usedModifiers) {
+    const tempName = `__ODDO_IMPORT_${name}__`;
+    const uniqueName = generateUid(name);
+    tempToUnique[tempName] = uniqueName;
+    modifierAliases[name] = uniqueName;
+  }
+  if (Object.keys(tempToUnique).length > 0) {
+    traverse(fileAST, {
+      noScope: true,
+      Identifier(path) {
+        if (tempToUnique[path.node.name]) {
+          path.node.name = tempToUnique[path.node.name];
+        }
+      }
+    });
+  }
+  const modifiersNeedingImport = Array.from(usedModifiers).filter((name) => {
+    const modifier = MODIFIER_TRANSFORMATIONS[name];
+    return !modifier || modifier.needsImport !== false;
+  });
+  if (modifiersNeedingImport.length > 0) {
+    const specifiers = modifiersNeedingImport.map((name) => {
+      return t.importSpecifier(
+        t.identifier(modifierAliases[name]),
+        // local: _state, _e
+        t.identifier(name)
+        // imported: state, e
+      );
+    });
+    const importDeclaration2 = t.importDeclaration(
+      specifiers,
+      t.stringLiteral(runtimeLibrary)
+    );
+    babelAST.body.unshift(importDeclaration2);
+  }
+  const output = generate(babelAST, {
+    compact: false,
+    comments: false
+  });
+  return output.code;
+}
+function convertProgram(ast) {
+  const body = [];
+  for (const stmt of ast.body) {
+    const converted = convertStatement2(stmt);
+    if (converted.type === "BlockStatement" && converted.body.length > 0) {
+      body.push(...converted.body);
+    } else {
+      body.push(converted);
+    }
+  }
+  return t.program(body);
+}
+function convertStatement2(stmt) {
+  switch (stmt.type) {
+    case "expressionStatement":
+      return convertExpressionStatement2(stmt);
+    case "returnStatement":
+      return convertReturnStatement2(stmt);
+    case "blockStatement":
+      return convertBlockStatement(stmt);
+    case "exportDefaultStatement":
+      return convertExportDefaultStatement(stmt);
+    case "exportNamedStatement":
+      return convertExportNamedStatement(stmt);
+    case "importStatement":
+      return convertImportStatement2(stmt);
+    case "importNamespaceStatement":
+      return convertImportNamespaceStatement(stmt);
+    default:
+      throw new Error(`Unknown statement type: ${stmt.type}`);
+  }
+}
+function convertExpressionStatement2(stmt) {
+  if (stmt.modifier) {
+    const modifierTransform = MODIFIER_TRANSFORMATIONS[stmt.modifier];
+    if (!modifierTransform) {
+      throw new Error(`Unknown modifier: @${stmt.modifier}`);
+    }
+    if (stmt.expression) {
+      let valueExpr = null;
+      let leftExpr = null;
+      if (stmt.expression.type === "variableDeclaration" || stmt.expression.type === "assignment") {
+        leftExpr = convertExpression2(stmt.expression.left);
+        if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+          valueExpr = stmt.expression.right;
+        } else {
+          valueExpr = convertExpression2(stmt.expression.right);
+        }
+      } else {
+        if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+          valueExpr = stmt.expression;
+        } else {
+          valueExpr = convertExpression2(stmt.expression);
+        }
+      }
+      const { transform } = modifierTransform;
+      usedModifiers.add(stmt.modifier);
+      const transformedStmt = transform(valueExpr, leftExpr);
+      return transformedStmt;
+    }
+    if (stmt.block) {
+      const transformedStatements = [];
+      for (const blockStmt of stmt.block.body) {
+        if (blockStmt.modifier) {
+          transformedStatements.push(convertStatement2(blockStmt));
+        } else if (blockStmt.type === "expressionStatement" && blockStmt.expression) {
+          let valueExpr = null;
+          let leftExpr = null;
+          if (blockStmt.expression.type === "variableDeclaration" || blockStmt.expression.type === "assignment") {
+            leftExpr = convertExpression2(blockStmt.expression.left);
+            valueExpr = convertExpression2(blockStmt.expression.right);
+          } else {
+            valueExpr = convertExpression2(blockStmt.expression);
+          }
+          const { transform } = modifierTransform;
+          usedModifiers.add(stmt.modifier);
+          const transformedStmt = transform(valueExpr, leftExpr);
+          transformedStatements.push(transformedStmt);
+        } else {
+          transformedStatements.push(convertStatement2(blockStmt));
+        }
+      }
+      return t.blockStatement(transformedStatements);
+    }
+  }
+  if (stmt.expression && stmt.expression.type === "variableDeclaration") {
+    const left = convertExpression2(stmt.expression.left);
+    const right = convertExpression2(stmt.expression.right);
+    const identifiers = extractIdentifiers(right);
+    const liftedExpr = createLiftedExpr(right, identifiers);
+    return t.variableDeclaration("const", [
+      t.variableDeclarator(left, liftedExpr || right)
+    ]);
+  }
+  let expression = null;
+  if (stmt.expression) {
+    expression = convertExpression2(stmt.expression);
+  }
+  if (stmt.block) {
+    const block = convertBlockStatement(stmt.block);
+    if (expression) {
+      return t.expressionStatement(
+        t.sequenceExpression([
+          expression,
+          t.callExpression(
+            t.arrowFunctionExpression([], block.body.length === 1 ? block.body[0].expression : t.blockStatement(block.body)),
+            []
+          )
+        ])
+      );
+    } else {
+      return t.expressionStatement(
+        t.callExpression(
+          t.arrowFunctionExpression([], block),
+          []
+        )
+      );
+    }
+  }
+  if (!expression) {
+    throw new Error("Expression statement must have expression or block");
+  }
+  if (stmt.expression && stmt.expression.type === "arraySliceAssignment") {
+    const sliceAssignment = convertExpression2(stmt.expression);
+    return t.expressionStatement(sliceAssignment);
+  }
+  return t.expressionStatement(expression);
+}
+function convertReturnStatement2(stmt) {
+  const argument = stmt.argument ? convertExpression2(stmt.argument) : null;
+  return t.returnStatement(argument);
+}
+function convertBlockStatement(stmt) {
+  const body = stmt.body.map(convertStatement2);
+  return t.blockStatement(body);
+}
+function convertExpression2(expr) {
+  if (!expr) return null;
+  switch (expr.type) {
+    case "identifier":
+      return t.identifier(expr.name);
+    case "number":
+      if (expr.raw) {
+        const node = t.numericLiteral(expr.value);
+        node.extra = { raw: expr.raw, rawValue: expr.value };
+        return node;
+      }
+      return t.numericLiteral(expr.value);
+    case "string":
+      return t.stringLiteral(expr.value);
+    case "templateLiteral":
+      return convertTemplateLiteral2(expr);
+    case "taggedTemplate":
+      return convertTaggedTemplate(expr);
+    case "boolean":
+      return t.booleanLiteral(expr.value);
+    case "null":
+      return t.nullLiteral();
+    case "array":
+      return convertArrayLiteral2(expr);
+    case "object":
+      return convertObjectLiteral2(expr);
+    case "arrowFunction":
+      return convertArrowFunction2(expr);
+    case "call":
+      return convertCallExpression(expr);
+    case "memberAccess":
+      return convertMemberExpression(expr);
+    case "arraySlice":
+      return convertArraySlice(expr);
+    case "binary":
+      return convertBinaryExpression(expr);
+    case "logical":
+      return convertLogicalExpression(expr);
+    case "nullishCoalescing":
+      return convertNullishCoalescing2(expr);
+    case "pipe":
+      return convertPipe2(expr);
+    case "compose":
+      return convertCompose2(expr);
+    case "unary":
+      return convertUnaryExpression(expr);
+    case "prefix":
+      return convertUpdateExpression(expr, true);
+    case "postfix":
+      return convertUpdateExpression(expr, false);
+    case "conditional":
+      return convertConditionalExpression(expr);
+    case "assignment":
+      return convertAssignmentExpression(expr);
+    case "arraySliceAssignment":
+      return convertArraySliceAssignment(expr);
+    case "arrayPattern":
+      return convertArrayPattern(expr);
+    case "objectPattern":
+      return convertObjectPattern(expr);
+    case "jsxElement":
+      return convertJSXElement2(expr);
+    case "jsxFragment":
+      return convertJSXFragment2(expr);
+    default:
+      throw new Error(`Unknown expression type: ${expr.type}`);
+  }
+}
+function convertArrayLiteral2(expr) {
+  const elements = expr.elements.map((el) => {
+    if (!el) return null;
+    if (el.type === "spreadElement") {
+      return t.spreadElement(convertExpression2(el.argument));
+    }
+    if (el.type === "spread") {
+      return t.spreadElement(convertExpression2(el.expression));
+    }
+    return convertExpression2(el);
+  }).filter(Boolean);
+  return t.arrayExpression(elements);
+}
+function convertObjectLiteral2(expr) {
+  const properties = expr.properties.map((prop) => {
+    if (prop.type === "spreadProperty") {
+      return t.spreadElement(convertExpression2(prop.argument));
+    }
+    const key = convertExpression2(prop.key);
+    const value = convertExpression2(prop.value);
+    const computed = prop.computed || false;
+    if (prop.shorthand) {
+      return t.objectProperty(key, value, computed, true);
+    }
+    return t.objectProperty(key, value, computed, false);
+  });
+  return t.objectExpression(properties);
+}
+function convertArrowFunction2(expr) {
+  const savedScope = currentScope;
+  if (expr._scope) {
+    currentScope = expr._scope;
+  }
+  const bodyIdentifiers = collectOddoIdentifiersOnly(expr.body);
+  const reactiveDepsForBody = bodyIdentifiers.filter((id) => {
+    var _a;
+    const isOwnParam = (_a = expr.parameters) == null ? void 0 : _a.some((p) => p.name === id);
+    if (isOwnParam) return false;
+    const varInfo = savedScope == null ? void 0 : savedScope[id];
+    return (varInfo == null ? void 0 : varInfo.reactive) === true;
+  });
+  for (const dep of reactiveDepsForBody) {
+    currentScope[dep] = { type: "param", reactive: false };
+  }
+  const params = expr.parameters.map((param) => {
+    if (param.type === "restElement") {
+      return t.restElement(convertExpression2(param.argument));
+    }
+    if (param.type === "destructuringPattern") {
+      const pattern = convertExpression2(param.pattern);
+      if (param.default) {
+        return t.assignmentPattern(pattern, convertExpression2(param.default));
+      }
+      return pattern;
+    }
+    if (param.type === "parameter") {
+      const paramId = t.identifier(param.name);
+      if (param.default) {
+        return t.assignmentPattern(paramId, convertExpression2(param.default));
+      }
+      return paramId;
+    }
+    return convertExpression2(param);
+  });
+  let body;
+  if (expr.body && expr.body.type === "blockStatement") {
+    const statements = expr.body.body.map((stmt) => convertStatement2(stmt));
+    body = t.blockStatement(statements);
+  } else if (expr.body) {
+    body = convertExpression2(expr.body);
+  } else {
+    body = null;
+  }
+  currentScope = savedScope;
+  if (reactiveDepsForBody.length > 0) {
+    usedModifiers.add("liftFn");
+    const depParams = reactiveDepsForBody.map((id) => t.identifier(id));
+    const allParams = [...depParams, ...params];
+    const depsArray = reactiveDepsForBody.map((id) => t.identifier(id));
+    const liftedFunc = t.arrowFunctionExpression(allParams, body);
+    return t.callExpression(
+      t.identifier(modifierAliases["liftFn"]),
+      [liftedFunc, t.arrayExpression(depsArray)]
+    );
+  }
+  return t.arrowFunctionExpression(params, body);
+}
+function collectOddoIdentifiersOnly(node, names = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object") return Array.from(names);
+  if (node.type === "identifier") {
+    names.add(node.name);
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "type") continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      val.forEach((item) => collectOddoIdentifiersOnly(item, names));
+    } else if (val && typeof val === "object") {
+      collectOddoIdentifiersOnly(val, names);
+    }
+  }
+  return Array.from(names);
+}
+function convertCallExpression(expr) {
+  const callee = convertExpression2(expr.callee);
+  const args = expr.arguments.map((arg) => {
+    if (arg.type === "spreadElement") {
+      return t.spreadElement(convertExpression2(arg.argument));
+    }
+    return convertExpression2(arg);
+  });
+  if (expr.optional) {
+    return t.optionalCallExpression(callee, args, true);
+  }
+  return t.callExpression(callee, args);
+}
+function convertTemplateLiteral2(expr) {
+  const quasis = expr.quasis.map((quasi) => {
+    return t.templateElement(
+      quasi.value,
+      quasi.tail
+    );
+  });
+  const expressions = expr.expressions.map((expr2) => convertExpression2(expr2));
+  return t.templateLiteral(quasis, expressions);
+}
+function convertTaggedTemplate(expr) {
+  const tag = convertExpression2(expr.tag);
+  const template = convertTemplateLiteral2(expr.template);
+  return t.taggedTemplateExpression(tag, template);
+}
+function convertMemberExpression(expr) {
+  const object = convertExpression2(expr.object);
+  const property = typeof expr.property === "string" ? t.identifier(expr.property) : convertExpression2(expr.property);
+  if (expr.optional) {
+    return t.optionalMemberExpression(object, property, expr.computed || false, true);
+  }
+  return t.memberExpression(object, property, expr.computed || false);
+}
+function convertArraySlice(expr) {
+  const object = convertExpression2(expr.object);
+  const args = [];
+  if (expr.start !== null && expr.start !== void 0) {
+    args.push(convertExpression2(expr.start));
+  } else {
+    args.push(t.numericLiteral(0));
+  }
+  if (expr.end !== null && expr.end !== void 0) {
+    args.push(convertExpression2(expr.end));
+  }
+  const sliceProperty = t.identifier("slice");
+  const sliceMember = t.memberExpression(object, sliceProperty, false);
+  return t.callExpression(sliceMember, args);
+}
+function convertBinaryExpression(expr) {
+  const left = convertExpression2(expr.left);
+  const right = convertExpression2(expr.right);
+  const operatorMap = {
+    "+": "+",
+    "-": "-",
+    "*": "*",
+    "/": "/",
+    "%": "%",
+    "**": "**",
+    "==": "===",
+    // Map == to === in JavaScript
+    "!=": "!==",
+    // Map != to !== in JavaScript
+    "<": "<",
+    "<=": "<=",
+    ">": ">",
+    ">=": ">=",
+    "<<": "<<",
+    ">>": ">>",
+    ">>>": ">>>",
+    "&": "&",
+    "^": "^",
+    "|": "|",
+    "instanceof": "instanceof",
+    "in": "in"
+  };
+  const operator = operatorMap[expr.operator] || expr.operator;
+  return t.binaryExpression(operator, left, right);
+}
+function convertLogicalExpression(expr) {
+  const left = convertExpression2(expr.left);
+  const right = convertExpression2(expr.right);
+  const operator = expr.operator === "&&" ? "&&" : "||";
+  return t.logicalExpression(operator, left, right);
+}
+function convertNullishCoalescing2(expr) {
+  const left = convertExpression2(expr.left);
+  const right = convertExpression2(expr.right);
+  return t.logicalExpression("??", left, right);
+}
+function convertPipe2(expr) {
+  const left = convertExpression2(expr.left);
+  const right = convertExpression2(expr.right);
+  return t.callExpression(right, [left]);
+}
+function convertCompose2(expr) {
+  const left = convertExpression2(expr.left);
+  const right = convertExpression2(expr.right);
+  return t.callExpression(left, [right]);
+}
+function convertUnaryExpression(expr) {
+  const argument = convertExpression2(expr.operand);
+  const operatorMap = {
+    "+": "+",
+    "-": "-",
+    "!": "!",
+    "~": "~",
+    "typeof": "typeof",
+    "void": "void",
+    "delete": "delete"
+  };
+  const operator = operatorMap[expr.operator] || expr.operator;
+  return t.unaryExpression(operator, argument);
+}
+function convertUpdateExpression(expr, prefix) {
+  const argument = convertExpression2(expr.operand);
+  const operator = expr.operator === "++" ? "++" : "--";
+  return t.updateExpression(operator, argument, prefix);
+}
+function convertConditionalExpression(expr) {
+  const test = convertExpression2(expr.test);
+  const consequent = convertExpression2(expr.consequent);
+  const alternate = convertExpression2(expr.alternate);
+  return t.conditionalExpression(test, consequent, alternate);
+}
+function convertAssignmentExpression(expr) {
+  const left = convertExpression2(expr.left);
+  const right = convertExpression2(expr.right);
+  const operatorMap = {
+    "=": "=",
+    ":=": "=",
+    // Map := to = in JavaScript
+    "+:=": "+=",
+    "-:=": "-=",
+    "*:=": "*=",
+    "/:=": "/=",
+    "%:=": "%=",
+    "**:=": "**=",
+    "<<:=": "<<=",
+    ">>:=": ">>=",
+    ">>>:=": ">>>=",
+    "&:=": "&=",
+    "^:=": "^=",
+    "|:=": "|="
+  };
+  const operator = operatorMap[expr.operator] || expr.operator;
+  return t.assignmentExpression(operator, left, right);
+}
+function convertArraySliceAssignment(expr) {
+  const slice = expr.slice;
+  const object = convertExpression2(slice.object);
+  const value = convertExpression2(expr.value);
+  let startExpr, deleteCountExpr;
+  if (slice.start === null || slice.start === void 0) {
+    startExpr = t.numericLiteral(0);
+    if (slice.end === null || slice.end === void 0) {
+      deleteCountExpr = t.memberExpression(
+        object,
+        t.identifier("length"),
+        false
+      );
+    } else {
+      deleteCountExpr = convertExpression2(slice.end);
+    }
+  } else {
+    startExpr = convertExpression2(slice.start);
+    if (slice.end === null || slice.end === void 0) {
+      deleteCountExpr = t.binaryExpression(
+        "-",
+        t.memberExpression(object, t.identifier("length"), false),
+        startExpr
+      );
+    } else {
+      const endExpr = convertExpression2(slice.end);
+      if (slice.start.type === "number" && slice.end.type === "number") {
+        const deleteCount = slice.end.value - slice.start.value;
+        deleteCountExpr = t.numericLiteral(deleteCount);
+      } else {
+        deleteCountExpr = t.binaryExpression("-", endExpr, startExpr);
+      }
+    }
+  }
+  const spliceArgs = t.arrayExpression([startExpr, deleteCountExpr]);
+  const concatCall = t.callExpression(
+    t.memberExpression(spliceArgs, t.identifier("concat"), false),
+    [value]
+  );
+  const spliceMethod = t.memberExpression(
+    t.memberExpression(
+      t.memberExpression(t.identifier("Array"), t.identifier("prototype"), false),
+      t.identifier("splice"),
+      false
+    ),
+    t.identifier("apply"),
+    false
+  );
+  return t.callExpression(spliceMethod, [object, concatCall]);
+}
+function convertArrayPattern(expr) {
+  const elements = expr.elements.map((el) => {
+    if (el.type === "restElement") {
+      return t.restElement(convertExpression2(el.argument));
+    }
+    return convertExpression2(el);
+  });
+  return t.arrayPattern(elements);
+}
+function convertObjectPattern(expr) {
+  const properties = expr.properties.map((prop) => {
+    if (prop.type === "restProperty") {
+      return t.restElement(convertExpression2(prop.argument));
+    }
+    const key = convertExpression2(prop.key);
+    let value = prop.shorthand ? null : convertExpression2(prop.value);
+    if (prop.default) {
+      const actualValue = value || key;
+      value = t.assignmentPattern(actualValue, convertExpression2(prop.default));
+    } else {
+      value = value || key;
+    }
+    const computed = prop.key && prop.key.type === "string";
+    return t.objectProperty(key, value, computed, prop.shorthand && !prop.default);
+  });
+  return t.objectPattern(properties);
+}
+function convertJSXChild2(child) {
+  if (child.type === "jsxText") {
+    const text = child.value;
+    if (!text.trim()) return null;
+    return t.stringLiteral(text);
+  } else if (child.type === "jsxExpression") {
+    const innerExpr = convertExpression2(child.expression);
+    return createReactiveExpr(innerExpr);
+  } else if (child.type === "jsxElement") {
+    return convertJSXElement2(child);
+  } else if (child.type === "jsxFragment") {
+    return convertJSXFragment2(child);
+  }
+  return null;
+}
+function convertJSXElement2(expr) {
+  const tagName = expr.name;
+  const isComponent = /^[A-Z]/.test(tagName);
+  const pragma = isComponent ? "c" : "e";
+  usedModifiers.add(pragma);
+  const hasSpread = expr.attributes.some((attr) => attr.type === "jsxSpread");
+  let propsArg;
+  if (hasSpread) {
+    const properties = [];
+    for (const attr of expr.attributes) {
+      if (attr.type === "jsxSpread") {
+        properties.push(t.spreadElement(convertExpression2(attr.expression)));
+      } else {
+        const key = t.identifier(attr.name);
+        let value;
+        if (attr.value === null) {
+          value = t.booleanLiteral(true);
+        } else if (attr.value.type === "string") {
+          value = t.stringLiteral(attr.value.value);
+        } else if (attr.value.type === "expression") {
+          value = convertExpression2(attr.value.value);
+        } else {
+          value = convertExpression2(attr.value);
+        }
+        properties.push(t.objectProperty(key, value));
+      }
+    }
+    const propsObj = t.objectExpression(properties);
+    propsArg = createReactiveExpr(propsObj, true);
+  } else if (expr.attributes.length === 0) {
+    propsArg = t.nullLiteral();
+  } else {
+    const properties = [];
+    for (const attr of expr.attributes) {
+      const key = t.identifier(attr.name);
+      let value;
+      if (attr.value === null) {
+        value = t.booleanLiteral(true);
+      } else if (attr.value.type === "string") {
+        value = t.stringLiteral(attr.value.value);
+      } else if (attr.value.type === "expression") {
+        const innerExpr = convertExpression2(attr.value.value);
+        value = createReactiveExpr(innerExpr, true);
+      } else {
+        const innerExpr = convertExpression2(attr.value);
+        value = createReactiveExpr(innerExpr, true);
+      }
+      properties.push(t.objectProperty(key, value));
+    }
+    propsArg = t.objectExpression(properties);
+  }
+  const children = expr.children.map(convertJSXChild2).filter(Boolean);
+  const tagArg = isComponent ? t.identifier(tagName) : t.stringLiteral(tagName);
+  const args = [tagArg, propsArg, ...children];
+  return t.callExpression(
+    t.identifier(modifierAliases[pragma]),
+    args
+  );
+}
+function convertJSXFragment2(expr) {
+  usedModifiers.add("f");
+  const children = expr.children.map(convertJSXChild2).filter(Boolean);
+  return t.callExpression(
+    t.identifier(modifierAliases["f"]),
+    children
+  );
+}
+function convertExportDefaultStatement(stmt) {
+  const declaration = convertExpression2(stmt.declaration);
+  return t.exportDefaultDeclaration(declaration);
+}
+function convertExportNamedStatement(stmt) {
+  if (stmt.declaration) {
+    const exprStmt = stmt.declaration;
+    if (exprStmt.type === "expressionStatement" && exprStmt.expression) {
+      if (exprStmt.expression.type === "variableDeclaration") {
+        const id = convertExpression2(exprStmt.expression.left);
+        const init = convertExpression2(exprStmt.expression.right);
+        const declaration2 = t.variableDeclaration("const", [
+          t.variableDeclarator(id, init)
+        ]);
+        return t.exportNamedDeclaration(declaration2, []);
+      }
+      if (exprStmt.expression.type === "assignment") {
+        const id = convertExpression2(exprStmt.expression.left);
+        const init = convertExpression2(exprStmt.expression.right);
+        const declaration2 = t.variableDeclaration("const", [
+          t.variableDeclarator(id, init)
+        ]);
+        return t.exportNamedDeclaration(declaration2, []);
+      }
+    }
+    const declaration = convertStatement2(stmt.declaration);
+    return t.exportNamedDeclaration(declaration, []);
+  }
+  const specifiers = stmt.specifiers.map((spec) => {
+    const local = t.identifier(spec.local);
+    const exported = spec.local === spec.exported ? local : t.identifier(spec.exported);
+    return t.exportSpecifier(local, exported);
+  });
+  return t.exportNamedDeclaration(null, specifiers);
+}
+function convertImportStatement2(stmt) {
+  const specifiers = [];
+  if (stmt.defaultImport) {
+    specifiers.push(t.importDefaultSpecifier(t.identifier(stmt.defaultImport)));
+  }
+  for (const spec of stmt.specifiers) {
+    const imported = spec.imported === spec.local ? t.identifier(spec.imported) : t.identifier(spec.imported);
+    const local = t.identifier(spec.local);
+    specifiers.push(t.importSpecifier(local, imported));
+  }
+  const source = t.stringLiteral(stmt.source);
+  return t.importDeclaration(specifiers, source);
+}
+function convertImportNamespaceStatement(stmt) {
+  const namespace = t.importNamespaceSpecifier(t.identifier(stmt.namespace));
+  const source = t.stringLiteral(stmt.source);
+  return t.importDeclaration([namespace], source);
+}
+
+// src/highlighter.mjs
+var tokenClassMap = {
+  // Keywords
+  "Return": "keyword",
+  "Import": "keyword",
+  "Export": "keyword",
+  "From": "keyword",
+  "Default": "keyword",
+  "As": "keyword",
+  // Keyword operators
+  "Typeof": "keyword",
+  "Void": "keyword",
+  "Delete": "keyword",
+  "Instanceof": "keyword",
+  "In": "keyword",
+  // Constants
+  "True": "constant",
+  "False": "constant",
+  "Null": "constant",
+  // Literals
+  "NumberLiteral": "number",
+  "StringLiteral": "string",
+  "TemplateLiteral": "string",
+  // Modifier
+  "Modifier": "modifier",
+  // Comments
+  "LineComment": "comment",
+  "MultiLineComment": "comment",
+  // Operators
+  "Equal": "operator",
+  "ColonEqual": "operator",
+  "PlusPlus": "operator",
+  "MinusMinus": "operator",
+  "Plus": "operator",
+  "Minus": "operator",
+  "Star": "operator",
+  "StarStar": "operator",
+  "Slash": "operator",
+  "Percent": "operator",
+  "EqualEqual": "operator",
+  "BangEqual": "operator",
+  "LessThan": "tag",
+  "GreaterThan": "tag",
+  "LessThanEqual": "operator",
+  "GreaterThanEqual": "operator",
+  "AndAnd": "operator",
+  "OrOr": "operator",
+  "Bang": "operator",
+  "Question": "operator",
+  "QuestionDot": "operator",
+  "QuestionQuestion": "operator",
+  "Colon": "operator",
+  "Pipe": "operator",
+  "Compose": "operator",
+  "DotDotDot": "operator",
+  "And": "operator",
+  "Or": "operator",
+  "Caret": "operator",
+  "Tilde": "operator",
+  "LeftShift": "operator",
+  "RightShift": "operator",
+  "UnsignedRightShift": "operator",
+  // Compound assignment
+  "PlusColonEqual": "operator",
+  "MinusColonEqual": "operator",
+  "StarColonEqual": "operator",
+  "StarStarColonEqual": "operator",
+  "SlashColonEqual": "operator",
+  "PercentColonEqual": "operator",
+  "LeftShiftColonEqual": "operator",
+  "RightShiftColonEqual": "operator",
+  "UnsignedRightShiftColonEqual": "operator",
+  "AndColonEqual": "operator",
+  "OrColonEqual": "operator",
+  "CaretColonEqual": "operator",
+  // JSX
+  "JSXCloseTagStart": "tag",
+  "JSXSelfClosing": "tag",
+  // Punctuation
+  "LeftParen": "punctuation",
+  "RightParen": "punctuation",
+  "LeftBracket": "punctuation",
+  "RightBracket": "punctuation",
+  "LeftBrace": "punctuation",
+  "RightBrace": "punctuation",
+  "Comma": "punctuation",
+  "Dot": "punctuation",
+  "Semicolon": "punctuation",
+  // Identifier - default
+  "Identifier": "identifier"
+};
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function highlightOddo(code) {
+  const text = String(code || "");
+  if (!text || text.trim() === "") {
+    return "";
+  }
+  const result = lexer.tokenize(text);
+  const tokens = result.tokens;
+  const comments = [
+    ...result.groups.LineComment || [],
+    ...result.groups.MultiLineComment || []
+  ];
+  const allTokenInstances = [...tokens, ...comments].sort((a, b) => a.startOffset - b.startOffset);
+  let html = "";
+  let lastEnd = 0;
+  for (const token of allTokenInstances) {
+    if (token.startOffset > lastEnd) {
+      const between = text.substring(lastEnd, token.startOffset);
+      html += escapeHtml(between);
+    }
+    const tokenType = token.tokenType.name;
+    const cssClass = tokenClassMap[tokenType] || "text";
+    const tokenText = escapeHtml(token.image);
+    html += `<span class="tok-${cssClass}">${tokenText}</span>`;
+    lastEnd = token.startOffset + token.image.length;
+  }
+  if (lastEnd < text.length) {
+    html += escapeHtml(text.substring(lastEnd));
+  }
+  return html;
+}
+function getHighlightingCSS() {
+  return `
+    .tok-keyword { color: #ff79c6; }
+    .tok-constant { color: #bd93f9; }
+    .tok-number { color: #bd93f9; }
+    .tok-string { color: #f1fa8c; }
+    .tok-modifier { color: #50fa7b; font-weight: 500; }
+    .tok-comment { color: #6272a4; font-style: italic; }
+    .tok-operator { color: #ff79c6; }
+    .tok-tag { color: #8be9fd; }
+    .tok-punctuation { color: #f8f8f2; }
+    .tok-identifier { color: #f8f8f2; }
+    .tok-text { color: #f8f8f2; }
+  `;
+}
+
+// src/index.mjs
+function tokenize(input) {
+  return lexer.tokenize(input);
+}
+function parseOddo(input) {
+  const lexResult = tokenize(input);
+  if (lexResult.errors.length > 0) {
+    const errors = lexResult.errors.map((err) => ({
+      message: err.message,
+      line: err.line,
+      column: err.column
+    }));
+    throw new Error(`Lexer errors: ${JSON.stringify(errors)}`);
+  }
+  parser.input = lexResult.tokens;
+  const cst = parser.program();
+  if (parser.errors.length > 0) {
+    const errors = parser.errors.map((err) => {
+      var _a, _b, _c;
+      return {
+        message: err.message,
+        token: (_a = err.token) == null ? void 0 : _a.image,
+        line: (_b = err.token) == null ? void 0 : _b.startLine,
+        column: (_c = err.token) == null ? void 0 : _c.startColumn
+      };
+    });
+    throw new Error(`Parser errors: ${JSON.stringify(errors)}`);
+  }
+  const ast = convertCSTToAST(cst);
+  return ast;
+}
+function parseOddoExpression(input) {
+  const lexResult = tokenize(input);
+  if (lexResult.errors.length > 0) {
+    const errors = lexResult.errors.map((err) => ({
+      message: err.message,
+      line: err.line,
+      column: err.column
+    }));
+    throw new Error(`Lexer errors: ${JSON.stringify(errors)}`);
+  }
+  parser.input = lexResult.tokens;
+  const cst = parser.expression();
+  if (parser.errors.length > 0) {
+    const errors = parser.errors.map((err) => {
+      var _a, _b, _c;
+      return {
+        message: err.message,
+        token: (_a = err.token) == null ? void 0 : _a.image,
+        line: (_b = err.token) == null ? void 0 : _b.startLine,
+        column: (_c = err.token) == null ? void 0 : _c.startColumn
+      };
+    });
+    throw new Error(`Parser errors: ${JSON.stringify(errors)}`);
+  }
+  const ast = convertExpression(cst);
+  return ast;
+}
+function compileOddoToJS(input, config = {}) {
+  const ast = parseOddo(input);
+  return compileToJS(ast, config);
+}
+function compileOddoExpressionToJS(input, config = {}) {
+  const ast = parseOddoExpression(input);
+  return compileToJS(ast, config);
+}
+
+
+
+
+
+
+
+exports.compileOddoExpressionToJS = compileOddoExpressionToJS; exports.compileOddoToJS = compileOddoToJS; exports.getHighlightingCSS = getHighlightingCSS; exports.highlightOddo = highlightOddo; exports.parseOddo = parseOddo; exports.parseOddoExpression = parseOddoExpression;
+//# sourceMappingURL=index.js.map