@hyperfixi/core 2.0.0 → 2.2.0

package/dist/parser/full-parser.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const KEYWORDS$1 = {
+const KEYWORDS = {
     THEN: 'then',
     ELSE: 'else',
     END: 'end',
@@ -29,11 +29,11 @@ const KEYWORDS$1 = {
     THE: 'the',
     START: 'start'};
 const COMMAND_TERMINATORS = [
-    KEYWORDS$1.THEN,
-    KEYWORDS$1.AND,
-    KEYWORDS$1.ELSE,
-    KEYWORDS$1.END,
-    KEYWORDS$1.ON,
+    KEYWORDS.THEN,
+    KEYWORDS.AND,
+    KEYWORDS.ELSE,
+    KEYWORDS.END,
+    KEYWORDS.ON,
 ];
 const COMMANDS = new Set([
     'add',
@@ -348,74 +348,6 @@ var TokenKind;
     TokenKind["SYMBOL"] = "symbol";
     TokenKind["UNKNOWN"] = "unknown";
 })(TokenKind || (TokenKind = {}));
-function getTokenKind(tokenType) {
-    switch (tokenType) {
-        case TokenType.KEYWORD:
-        case TokenType.COMMAND:
-        case TokenType.EXPRESSION:
-        case TokenType.CONTEXT_VAR:
-        case TokenType.GLOBAL_VAR:
-        case TokenType.EVENT:
-        case TokenType.IDENTIFIER:
-            return TokenKind.IDENTIFIER;
-        case TokenType.STRING:
-            return TokenKind.STRING;
-        case TokenType.NUMBER:
-            return TokenKind.NUMBER;
-        case TokenType.BOOLEAN:
-            return TokenKind.IDENTIFIER;
-        case TokenType.TEMPLATE_LITERAL:
-            return TokenKind.TEMPLATE;
-        case TokenType.CSS_SELECTOR:
-        case TokenType.ID_SELECTOR:
-        case TokenType.CLASS_SELECTOR:
-        case TokenType.QUERY_REFERENCE:
-            return TokenKind.SELECTOR;
-        case TokenType.OPERATOR:
-        case TokenType.LOGICAL_OPERATOR:
-        case TokenType.COMPARISON_OPERATOR:
-            return TokenKind.OPERATOR;
-        case TokenType.TIME_EXPRESSION:
-            return TokenKind.TIME;
-        case TokenType.COMMENT:
-            return TokenKind.COMMENT;
-        case TokenType.SYMBOL:
-            return TokenKind.SYMBOL;
-        case TokenType.OBJECT_LITERAL:
-        case TokenType.ARRAY_LITERAL:
-        case TokenType.UNKNOWN:
-        default:
-            return TokenKind.UNKNOWN;
-    }
-}
-var TokenType;
-(function (TokenType) {
-    TokenType["KEYWORD"] = "keyword";
-    TokenType["COMMAND"] = "command";
-    TokenType["EXPRESSION"] = "expression";
-    TokenType["STRING"] = "string";
-    TokenType["NUMBER"] = "number";
-    TokenType["BOOLEAN"] = "boolean";
-    TokenType["TEMPLATE_LITERAL"] = "template_literal";
-    TokenType["CSS_SELECTOR"] = "css_selector";
-    TokenType["ID_SELECTOR"] = "id_selector";
-    TokenType["CLASS_SELECTOR"] = "class_selector";
-    TokenType["QUERY_REFERENCE"] = "query_reference";
-    TokenType["CONTEXT_VAR"] = "context_var";
-    TokenType["GLOBAL_VAR"] = "global_var";
-    TokenType["EVENT"] = "event";
-    TokenType["OPERATOR"] = "operator";
-    TokenType["LOGICAL_OPERATOR"] = "logical_operator";
-    TokenType["COMPARISON_OPERATOR"] = "comparison_operator";
-    TokenType["TIME_EXPRESSION"] = "time_expression";
-    TokenType["OBJECT_LITERAL"] = "object_literal";
-    TokenType["ARRAY_LITERAL"] = "array_literal";
-    TokenType["SYMBOL"] = "symbol";
-    TokenType["COMMENT"] = "comment";
-    TokenType["IDENTIFIER"] = "identifier";
-    TokenType["UNKNOWN"] = "unknown";
-})(TokenType || (TokenType = {}));
-const KEYWORDS = TOKENIZER_KEYWORDS;
 const MATHEMATICAL_OPERATORS = new Set(['+', '-', '*', '/', 'mod']);
 const TIME_UNITS = new Set(['ms', 's', 'seconds', 'minutes', 'hours', 'days']);
 function createTokenizer() {
@@ -458,7 +390,7 @@ function tokenize(input) {
                 const start = tokenizer.position;
                 advance(tokenizer);
                 advance(tokenizer);
-                addToken(tokenizer, TokenType.OPERATOR, "'s", start);
+                addToken(tokenizer, TokenKind.OPERATOR, "'s", start);
             }
             else {
                 tokenizeString(tokenizer);
@@ -488,7 +420,7 @@ function tokenize(input) {
                 const start = tokenizer.position;
                 advance(tokenizer);
                 advance(tokenizer);
-                addToken(tokenizer, TokenType.OPERATOR, '..', start);
+                addToken(tokenizer, TokenKind.OPERATOR, '..', start);
                 continue;
             }
             const prevToken = tokenizer.tokens[tokenizer.tokens.length - 1];
@@ -533,46 +465,45 @@ function tokenize(input) {
             continue;
         }
         if (char === '{') {
-            addToken(tokenizer, TokenType.OPERATOR, '{');
+            addToken(tokenizer, TokenKind.OPERATOR, '{');
             advance(tokenizer);
             continue;
         }
         if (char === '}') {
-            addToken(tokenizer, TokenType.OPERATOR, '}');
+            addToken(tokenizer, TokenKind.OPERATOR, '}');
             advance(tokenizer);
             continue;
         }
         if (char === '[') {
             const prevToken = tokenizer.tokens[tokenizer.tokens.length - 1];
             const isEventCondition = prevToken &&
-                (prevToken.kind === TokenType.EVENT ||
-                    (prevToken.kind === TokenType.IDENTIFIER && DOM_EVENTS.has(prevToken.value))) &&
+                prevToken.kind === TokenKind.IDENTIFIER &&
+                DOM_EVENTS.has(prevToken.value) &&
                 tokenizer.tokens.length >= 2 &&
                 tokenizer.tokens[tokenizer.tokens.length - 2]?.value === 'on';
             const isMemberAccess = prevToken &&
-                (prevToken.kind === TokenType.IDENTIFIER ||
-                    prevToken.kind === TokenType.CONTEXT_VAR ||
+                (prevToken.kind === TokenKind.IDENTIFIER ||
                     prevToken.value === ')' ||
                     prevToken.value === ']') &&
                 !isEventCondition;
             if (isMemberAccess) {
-                addToken(tokenizer, TokenType.OPERATOR, '[');
+                addToken(tokenizer, TokenKind.OPERATOR, '[');
                 advance(tokenizer);
             }
             else {
                 if (isEventCondition) {
-                    addToken(tokenizer, TokenType.SYMBOL, '[');
+                    addToken(tokenizer, TokenKind.SYMBOL, '[');
                     advance(tokenizer);
                 }
                 else {
-                    addToken(tokenizer, TokenType.OPERATOR, '[');
+                    addToken(tokenizer, TokenKind.OPERATOR, '[');
                     advance(tokenizer);
                 }
             }
             continue;
         }
         if (char === ']') {
-            addToken(tokenizer, TokenType.OPERATOR, ']');
+            addToken(tokenizer, TokenKind.OPERATOR, ']');
             advance(tokenizer);
             continue;
         }
@@ -597,7 +528,7 @@ function tokenize(input) {
             tokenizeIdentifier(tokenizer);
             continue;
         }
-        addToken(tokenizer, TokenType.UNKNOWN, char);
+        addToken(tokenizer, TokenKind.UNKNOWN, char);
         advance(tokenizer);
     }
     return tokenizer.tokens;
@@ -639,7 +570,7 @@ function skipWhitespace(tokenizer) {
         }
     }
 }
-function addToken(tokenizer, type, value, start, end) {
+function addToken(tokenizer, kind, value, start, end) {
     const tokenStart = start ?? tokenizer.position - value.length;
     const tokenEnd = tokenizer.position;
     let tokenColumn = tokenizer.column - value.length;
@@ -654,7 +585,7 @@ function addToken(tokenizer, type, value, start, end) {
         tokenColumn = start - lastNewlinePos;
     }
     const token = {
-        kind: getTokenKind(type),
+        kind,
         value,
         start: tokenStart,
         end: tokenEnd,
@@ -690,7 +621,7 @@ function tokenizeComment(tokenizer) {
             break;
         value += advance(tokenizer);
     }
-    addToken(tokenizer, TokenType.COMMENT, '--' + value, start);
+    addToken(tokenizer, TokenKind.COMMENT, '--' + value, start);
 }
 function tokenizeString(tokenizer) {
     const start = tokenizer.position;
@@ -707,7 +638,7 @@ function tokenizeString(tokenizer) {
             }
         }
     }
-    addToken(tokenizer, TokenType.STRING, value, start);
+    addToken(tokenizer, TokenKind.STRING, value, start);
 }
 function tokenizeTemplateLiteral(tokenizer) {
     const start = tokenizer.position;
@@ -751,7 +682,7 @@ function tokenizeTemplateLiteral(tokenizer) {
     if (tokenizer.position >= tokenizer.input.length && !tokenizer.input.endsWith('`')) {
         throw new Error(`Unterminated template literal at line ${tokenizer.line}, column ${tokenizer.column - value.length}`);
     }
-    addToken(tokenizer, TokenType.TEMPLATE_LITERAL, value, start);
+    addToken(tokenizer, TokenKind.TEMPLATE, value, start);
 }
 function tokenizeCSSSelector(tokenizer) {
     const start = tokenizer.position;
@@ -766,8 +697,7 @@ function tokenizeCSSSelector(tokenizer) {
             break;
         }
     }
-    const type = prefix === '#' ? TokenType.ID_SELECTOR : TokenType.CLASS_SELECTOR;
-    addToken(tokenizer, type, value, start);
+    addToken(tokenizer, TokenKind.SELECTOR, value, start);
 }
 function tokenizeQueryReference(tokenizer) {
     const start = tokenizer.position;
@@ -782,7 +712,7 @@ function tokenizeQueryReference(tokenizer) {
             break;
         }
     }
-    addToken(tokenizer, TokenType.QUERY_REFERENCE, value, start);
+    addToken(tokenizer, TokenKind.SELECTOR, value, start);
 }
 function tokenizeSymbol(tokenizer) {
     const start = tokenizer.position;
@@ -796,7 +726,7 @@ function tokenizeSymbol(tokenizer) {
             break;
         }
     }
-    addToken(tokenizer, TokenType.SYMBOL, value, start);
+    addToken(tokenizer, TokenKind.SYMBOL, value, start);
 }
 function tokenizeOperator(tokenizer) {
     const start = tokenizer.position;
@@ -806,7 +736,7 @@ function tokenizeOperator(tokenizer) {
         value = "'s";
         advance(tokenizer);
         advance(tokenizer);
-        addToken(tokenizer, TokenType.OPERATOR, value, start);
+        addToken(tokenizer, TokenKind.OPERATOR, value, start);
         return;
     }
     const twoChar = tokenizer.input.substring(tokenizer.position, tokenizer.position + 2);
@@ -825,17 +755,7 @@ function tokenizeOperator(tokenizer) {
     else {
         value = advance(tokenizer);
     }
-    let type = TokenType.OPERATOR;
-    if (COMPARISON_OPERATORS.has(value)) {
-        type = TokenType.COMPARISON_OPERATOR;
-    }
-    else if (['&&', '||'].includes(value)) {
-        type = TokenType.LOGICAL_OPERATOR;
-    }
-    else if (MATHEMATICAL_OPERATORS.has(value)) {
-        type = TokenType.OPERATOR;
-    }
-    addToken(tokenizer, type, value, start);
+    addToken(tokenizer, TokenKind.OPERATOR, value, start);
 }
 function tokenizeNumberOrTime(tokenizer) {
     const start = tokenizer.position;
@@ -901,11 +821,11 @@ function tokenizeNumberOrTime(tokenizer) {
         }
     }
     if (TIME_UNITS.has(unit)) {
-        addToken(tokenizer, TokenType.TIME_EXPRESSION, value + unit, start);
+        addToken(tokenizer, TokenKind.TIME, value + unit, start);
     }
     else {
         tokenizer.position = unitStart;
-        addToken(tokenizer, TokenType.NUMBER, value, start);
+        addToken(tokenizer, TokenKind.NUMBER, value, start);
     }
 }
 function tokenizeIdentifier(tokenizer) {
@@ -951,7 +871,7 @@ function tokenizeGlobalVariable(tokenizer) {
             break;
         }
     }
-    addToken(tokenizer, TokenType.GLOBAL_VAR, value, start);
+    addToken(tokenizer, TokenKind.IDENTIFIER, value, start);
 }
 function tryTokenizeCompoundOperator(tokenizer, firstWord, start) {
     const lowerFirst = firstWord.toLowerCase();
@@ -961,10 +881,7 @@ function tryTokenizeCompoundOperator(tokenizer, firstWord, start) {
     }
     const prevToken = tokenizer.tokens[tokenizer.tokens.length - 1];
     if (prevToken &&
-        (prevToken.kind === 'identifier' ||
-            prevToken.kind === 'id_selector' ||
-            prevToken.kind === 'class_selector' ||
-            prevToken.kind === 'context_var')) {
+        (prevToken.kind === TokenKind.IDENTIFIER || prevToken.kind === TokenKind.SELECTOR)) {
         const nextChar = tokenizer.position < tokenizer.input.length ? tokenizer.input[tokenizer.position] : '';
         if (nextChar === "'" || nextChar === "'") {
             return false;
@@ -994,17 +911,17 @@ function tryTokenizeCompoundOperator(tokenizer, firstWord, start) {
         }
         const longestCompound = tryBuildLongestCompound(tokenizer, lowerFirst, lowerNext);
         if (longestCompound) {
-            addToken(tokenizer, TokenType.COMPARISON_OPERATOR, longestCompound, start);
+            addToken(tokenizer, TokenKind.OPERATOR, longestCompound, start);
             return true;
         }
         if (COMPARISON_OPERATORS.has(compound)) {
-            addToken(tokenizer, TokenType.COMPARISON_OPERATOR, compound, start);
+            addToken(tokenizer, TokenKind.OPERATOR, compound, start);
             return true;
         }
     }
     if (COMPARISON_OPERATORS.has(lowerFirst)) {
         tokenizer.position = originalPosition;
-        addToken(tokenizer, TokenType.COMPARISON_OPERATOR, firstWord, start);
+        addToken(tokenizer, TokenKind.OPERATOR, firstWord, start);
         return true;
     }
     tokenizer.position = originalPosition;
@@ -1051,7 +968,7 @@ function tryBuildCompoundPreposition(tokenizer, firstWord, secondWord, start) {
                 const lowerFourth = fourthWord.toLowerCase();
                 if (lowerFourth === 'of') {
                     const compound = `at the ${lowerThird} of`;
-                    addToken(tokenizer, TokenType.KEYWORD, compound, start);
+                    addToken(tokenizer, TokenKind.IDENTIFIER, compound, start);
                     return true;
                 }
             }
@@ -1077,7 +994,7 @@ function tryBuildCompoundPreposition(tokenizer, firstWord, secondWord, start) {
             const lowerThird = thirdWord.toLowerCase();
             if (lowerThird === 'of') {
                 const compound = `at ${lowerSecond} of`;
-                addToken(tokenizer, TokenType.KEYWORD, compound, start);
+                addToken(tokenizer, TokenKind.IDENTIFIER, compound, start);
                 return true;
             }
             tokenizer.position = afterSecondWord;
@@ -1089,36 +1006,18 @@ function tryBuildCompoundPreposition(tokenizer, firstWord, secondWord, start) {
 function classifyIdentifier(value) {
     const lowerValue = value.toLowerCase();
     if (lowerValue === 'include' || lowerValue === 'includes') {
-        return TokenType.COMPARISON_OPERATOR;
+        return TokenKind.OPERATOR;
     }
     if (LOGICAL_OPERATORS.has(lowerValue)) {
-        return TokenType.LOGICAL_OPERATOR;
+        return TokenKind.OPERATOR;
     }
     if (MATHEMATICAL_OPERATORS.has(value) || MATHEMATICAL_OPERATORS.has(lowerValue)) {
-        return TokenType.OPERATOR;
+        return TokenKind.OPERATOR;
     }
     if (COMPARISON_OPERATORS.has(lowerValue)) {
-        return TokenType.COMPARISON_OPERATOR;
-    }
-    if (value === 'I') {
-        return TokenType.CONTEXT_VAR;
+        return TokenKind.OPERATOR;
     }
-    if (CONTEXT_VARS.has(lowerValue)) {
-        return TokenType.CONTEXT_VAR;
-    }
-    if (COMMANDS.has(lowerValue)) {
-        return TokenType.COMMAND;
-    }
-    if (DOM_EVENTS.has(lowerValue)) {
-        return TokenType.EVENT;
-    }
-    if (['true', 'false', 'null', 'undefined'].includes(lowerValue)) {
-        return TokenType.BOOLEAN;
-    }
-    if (KEYWORDS.has(lowerValue)) {
-        return TokenType.KEYWORD;
-    }
-    return TokenType.IDENTIFIER;
+    return TokenKind.IDENTIFIER;
 }
 function isAlpha(char) {
     return /[a-zA-Z]/.test(char);
@@ -1384,6 +1283,9 @@ class SemanticIntegrationAdapter {
         if (/\btell\b/.test(lowerInput)) {
             return true;
         }
+        if (/\*[a-zA-Z]/.test(input)) {
+            return true;
+        }
         return false;
     }
     trySemanticParse(input) {
@@ -2134,6 +2036,26 @@ function createErrorNode(pos) {
         column: pos.column,
     };
 }
+function createErrorCommandNode(pos, message, source) {
+    const diagnostic = {
+        message,
+        severity: 'error',
+        code: 'parse-error',
+        line: pos.line,
+        column: pos.column,
+        ...(source && { source }),
+    };
+    return {
+        type: 'command',
+        name: '__ERROR__',
+        args: [],
+        diagnostics: [diagnostic],
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
 function createProgramNode(statements) {
     debug.parse(`✅ createProgramNode: Called with ${statements.length} statements`);
     if (statements.length === 0) {
@@ -2178,10 +2100,10 @@ function isKeyword(token, keywords) {
     return keywords.some(kw => token.value === kw || token.value.toLowerCase() === kw);
 }
 const DEFAULT_BOUNDARY_KEYWORDS = [
-    KEYWORDS$1.THEN,
-    KEYWORDS$1.AND,
-    KEYWORDS$1.ELSE,
-    KEYWORDS$1.END,
+    KEYWORDS.THEN,
+    KEYWORDS.AND,
+    KEYWORDS.ELSE,
+    KEYWORDS.END,
 ];
 function isCommandBoundary(ctx, additionalBoundaries = []) {
     if (ctx.isAtEnd()) {
@@ -2491,21 +2413,21 @@ function parseTriggerCommand(ctx, identifierNode) {
 
 function parseHaltCommand(ctx, identifierNode) {
     const args = [];
-    if (ctx.check(KEYWORDS$1.THE)) {
+    if (ctx.check(KEYWORDS.THE)) {
         const theToken = ctx.advance();
         args.push({
             type: 'identifier',
-            name: KEYWORDS$1.THE,
+            name: KEYWORDS.THE,
             start: theToken.start,
             end: theToken.end,
             line: theToken.line,
             column: theToken.column,
         });
-        if (ctx.check(KEYWORDS$1.EVENT)) {
+        if (ctx.check(KEYWORDS.EVENT)) {
             const eventToken = ctx.advance();
             args.push({
                 type: 'identifier',
-                name: KEYWORDS$1.EVENT,
+                name: KEYWORDS.EVENT,
                 start: eventToken.start,
                 end: eventToken.end,
                 line: eventToken.line,
@@ -2527,34 +2449,34 @@ function parseRepeatCommand(ctx, commandToken) {
     let collection = null;
     let variable = null;
     let times = null;
-    if (ctx.check(KEYWORDS$1.FOR)) {
+    if (ctx.check(KEYWORDS.FOR)) {
         ctx.advance();
-        loopType = KEYWORDS$1.FOR;
+        loopType = KEYWORDS.FOR;
         const identToken = ctx.peek();
         if (isIdentifierLike(identToken)) {
             variable = identToken.value;
             ctx.advance();
         }
-        if (ctx.check(KEYWORDS$1.IN)) {
+        if (ctx.check(KEYWORDS.IN)) {
             ctx.advance();
             collection = ctx.parseExpression();
         }
     }
-    else if (ctx.check(KEYWORDS$1.IN)) {
+    else if (ctx.check(KEYWORDS.IN)) {
         ctx.advance();
-        loopType = KEYWORDS$1.FOR;
+        loopType = KEYWORDS.FOR;
         variable = 'it';
         collection = ctx.parseExpression();
     }
-    else if (ctx.check(KEYWORDS$1.WHILE)) {
+    else if (ctx.check(KEYWORDS.WHILE)) {
         ctx.advance();
-        loopType = KEYWORDS$1.WHILE;
+        loopType = KEYWORDS.WHILE;
         condition = ctx.parseExpression();
     }
-    else if (ctx.check(KEYWORDS$1.UNTIL)) {
+    else if (ctx.check(KEYWORDS.UNTIL)) {
         ctx.advance();
-        loopType = KEYWORDS$1.UNTIL;
-        if (ctx.check(KEYWORDS$1.EVENT)) {
+        loopType = KEYWORDS.UNTIL;
+        if (ctx.check(KEYWORDS.EVENT)) {
             ctx.advance();
             loopType = 'until-event';
             const eventToken = ctx.peek();
@@ -2571,11 +2493,11 @@ function parseRepeatCommand(ctx, commandToken) {
                 throw new Error('Expected event name after "event"');
             }
             debug.parse('🔍 Checking for "from", current token:', ctx.peek().value);
-            if (ctx.check(KEYWORDS$1.FROM)) {
+            if (ctx.check(KEYWORDS.FROM)) {
                 debug.parse('✅ Found "from", advancing...');
                 ctx.advance();
                 debug.parse('📍 After consuming "from", current token:', ctx.peek().value);
-                if (consumeOptionalKeyword(ctx, KEYWORDS$1.THE)) {
+                if (consumeOptionalKeyword(ctx, KEYWORDS.THE)) {
                     debug.parse('✅ Found "the", advancing...');
                 }
                 const beforePrimary = ctx.peek();
@@ -2595,27 +2517,27 @@ function parseRepeatCommand(ctx, commandToken) {
             condition = ctx.parseExpression();
         }
     }
-    else if (ctx.check(KEYWORDS$1.FOREVER)) {
+    else if (ctx.check(KEYWORDS.FOREVER)) {
         ctx.advance();
-        loopType = KEYWORDS$1.FOREVER;
+        loopType = KEYWORDS.FOREVER;
     }
     else {
         times = ctx.parseExpression();
-        if (ctx.check(KEYWORDS$1.TIMES)) {
+        if (ctx.check(KEYWORDS.TIMES)) {
             ctx.advance();
-            loopType = KEYWORDS$1.TIMES;
+            loopType = KEYWORDS.TIMES;
         }
     }
     let indexVariable = null;
-    if (ctx.check(KEYWORDS$1.WITH)) {
+    if (ctx.check(KEYWORDS.WITH)) {
         const nextToken = ctx.peekAt(1);
-        if (nextToken && nextToken.value.toLowerCase() === KEYWORDS$1.INDEX) {
+        if (nextToken && nextToken.value.toLowerCase() === KEYWORDS.INDEX) {
             ctx.advance();
             ctx.advance();
-            indexVariable = KEYWORDS$1.INDEX;
+            indexVariable = KEYWORDS.INDEX;
         }
     }
-    else if (ctx.check(KEYWORDS$1.INDEX)) {
+    else if (ctx.check(KEYWORDS.INDEX)) {
         ctx.advance();
         const indexToken = ctx.peek();
         if (isIdentifierLike(indexToken)) {
@@ -2623,7 +2545,7 @@ function parseRepeatCommand(ctx, commandToken) {
             ctx.advance();
         }
         else {
-            indexVariable = KEYWORDS$1.INDEX;
+            indexVariable = KEYWORDS.INDEX;
         }
     }
     const commands = ctx.parseCommandListUntilEnd();
@@ -2671,14 +2593,14 @@ function parseIfCommand(ctx, commandToken) {
     const maxThenLookahead = 500;
     for (let i = 0; i < maxThenLookahead && !ctx.isAtEnd(); i++) {
         const token = ctx.peek();
-        if (token.value === KEYWORDS$1.THEN) {
+        if (token.value === KEYWORDS.THEN) {
             hasThen = true;
             break;
         }
-        if (token.value === KEYWORDS$1.END ||
-            token.value === KEYWORDS$1.BEHAVIOR ||
-            token.value === KEYWORDS$1.DEF ||
-            token.value === KEYWORDS$1.ON) {
+        if (token.value === KEYWORDS.END ||
+            token.value === KEYWORDS.BEHAVIOR ||
+            token.value === KEYWORDS.DEF ||
+            token.value === KEYWORDS.ON) {
             break;
         }
         ctx.advance();
@@ -2692,12 +2614,12 @@ function parseIfCommand(ctx, commandToken) {
         while (!ctx.isAtEnd() && ctx.current - savedPosition < maxLookahead) {
             const token = ctx.peek();
             const tokenValue = token.value?.toLowerCase();
-            if (tokenValue === KEYWORDS$1.BEHAVIOR ||
-                tokenValue === KEYWORDS$1.DEF ||
-                tokenValue === KEYWORDS$1.ON) {
+            if (tokenValue === KEYWORDS.BEHAVIOR ||
+                tokenValue === KEYWORDS.DEF ||
+                tokenValue === KEYWORDS.ON) {
                 break;
             }
-            if (tokenValue === KEYWORDS$1.ELSE || tokenValue === KEYWORDS$1.END) {
+            if (tokenValue === KEYWORDS.ELSE || tokenValue === KEYWORDS.END) {
                 if (token.line === ifStatementLine) {
                     hasImplicitMultiLineEnd = true;
                 }
@@ -2725,7 +2647,7 @@ function parseIfCommand(ctx, commandToken) {
         while (!ctx.isAtEnd() &&
             !ctx.checkIsCommand() &&
             !ctx.isCommand(ctx.peek().value) &&
-            !ctx.check(KEYWORDS$1.THEN) &&
+            !ctx.check(KEYWORDS.THEN) &&
             iterations < maxIterations) {
             const beforePos = ctx.savePosition();
             conditionTokens.push(ctx.parseLogicalAnd());
@@ -2757,7 +2679,7 @@ function parseIfCommand(ctx, commandToken) {
             ctx.advance();
         }
         const thenCommands = [];
-        while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.ELSE) && !ctx.check(KEYWORDS$1.END)) {
+        while (!ctx.isAtEnd() && !ctx.check(KEYWORDS.ELSE) && !ctx.check(KEYWORDS.END)) {
             if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
                 ctx.advance();
                 const cmd = ctx.parseCommand();
@@ -2779,9 +2701,9 @@ function parseIfCommand(ctx, commandToken) {
             column: commandToken.column,
         }));
         let consumedElseIf = false;
-        if (ctx.check(KEYWORDS$1.ELSE)) {
+        if (ctx.check(KEYWORDS.ELSE)) {
             ctx.advance();
-            if (ctx.check(KEYWORDS$1.IF)) {
+            if (ctx.check(KEYWORDS.IF)) {
                 const ifToken = ctx.peek();
                 ctx.advance();
                 const elseIfCommand = parseIfCommand(ctx, ifToken);
@@ -2795,7 +2717,7 @@ function parseIfCommand(ctx, commandToken) {
             }
             else {
                 const elseCommands = [];
-                while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.END)) {
+                while (!ctx.isAtEnd() && !ctx.check(KEYWORDS.END)) {
                     if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
                         ctx.advance();
                         const cmd = ctx.parseCommand();
@@ -2816,7 +2738,7 @@ function parseIfCommand(ctx, commandToken) {
             }
         }
         if (!consumedElseIf) {
-            ctx.consume(KEYWORDS$1.END, "Expected 'end' after if block");
+            ctx.consume(KEYWORDS.END, "Expected 'end' after if block");
         }
     }
     else {
@@ -2843,7 +2765,7 @@ function parseForCommand(ctx, commandToken) {
     const args = [];
     let variable = null;
     let collection = null;
-    if (ctx.check(KEYWORDS$1.EACH)) {
+    if (ctx.check(KEYWORDS.EACH)) {
         ctx.advance();
     }
     const identToken = ctx.peek();
@@ -2854,7 +2776,7 @@ function parseForCommand(ctx, commandToken) {
     else {
         throw new Error('Expected variable name after "for"');
     }
-    if (!ctx.check(KEYWORDS$1.IN)) {
+    if (!ctx.check(KEYWORDS.IN)) {
         throw new Error('Expected "in" after variable name in for loop');
     }
     ctx.advance();
@@ -2863,15 +2785,15 @@ function parseForCommand(ctx, commandToken) {
         throw new Error('Expected collection expression after "in"');
     }
     let indexVariable = null;
-    if (ctx.check(KEYWORDS$1.WITH)) {
+    if (ctx.check(KEYWORDS.WITH)) {
         const nextToken = ctx.peekAt(1);
-        if (nextToken && nextToken.value.toLowerCase() === KEYWORDS$1.INDEX) {
+        if (nextToken && nextToken.value.toLowerCase() === KEYWORDS.INDEX) {
             ctx.advance();
             ctx.advance();
-            indexVariable = KEYWORDS$1.INDEX;
+            indexVariable = KEYWORDS.INDEX;
         }
     }
-    else if (ctx.check(KEYWORDS$1.INDEX)) {
+    else if (ctx.check(KEYWORDS.INDEX)) {
         ctx.advance();
         const indexToken = ctx.peek();
         if (isIdentifierLike(indexToken)) {
@@ -2879,7 +2801,7 @@ function parseForCommand(ctx, commandToken) {
             ctx.advance();
         }
         else {
-            indexVariable = KEYWORDS$1.INDEX;
+            indexVariable = KEYWORDS.INDEX;
         }
     }
     const commands = ctx.parseCommandListUntilEnd();
@@ -2991,7 +2913,7 @@ function parseTransitionCommand(ctx, commandToken) {
         throw new Error('Transition command requires a CSS property');
     }
     args.push(property);
-    if (!ctx.check(KEYWORDS$1.TO)) {
+    if (!ctx.check(KEYWORDS.TO)) {
         throw new Error('Expected "to" keyword after property in transition command');
     }
     ctx.advance();
@@ -3002,7 +2924,7 @@ function parseTransitionCommand(ctx, commandToken) {
         const duration = ctx.parsePrimary();
         modifiers['over'] = duration;
     }
-    if (ctx.check(KEYWORDS$1.WITH)) {
+    if (ctx.check(KEYWORDS.WITH)) {
         ctx.advance();
         const timingFunction = ctx.parsePrimary();
         modifiers['with'] = timingFunction;
@@ -3016,11 +2938,11 @@ function parseTransitionCommand(ctx, commandToken) {
 
 function parseRemoveCommand(ctx, identifierNode) {
     const args = [];
-    const classArg = parseOneArgument(ctx, [KEYWORDS$1.FROM]);
+    const classArg = parseOneArgument(ctx, [KEYWORDS.FROM]);
     if (classArg) {
         args.push(classArg);
     }
-    consumeKeywordToArgs(ctx, KEYWORDS$1.FROM, args);
+    consumeKeywordToArgs(ctx, KEYWORDS.FROM, args);
     const targetArg = parseOneArgument(ctx);
     if (targetArg) {
         args.push(targetArg);
@@ -3032,19 +2954,19 @@ function parseRemoveCommand(ctx, identifierNode) {
 }
 function parseToggleCommand(ctx, identifierNode) {
     const args = [];
-    if (ctx.check(KEYWORDS$1.BETWEEN)) {
+    if (ctx.check(KEYWORDS.BETWEEN)) {
         ctx.advance();
         args.push(ctx.createIdentifier('between'));
-        const firstArg = parseOneArgument(ctx, [KEYWORDS$1.AND]);
+        const firstArg = parseOneArgument(ctx, [KEYWORDS.AND]);
         if (firstArg) {
             args.push(firstArg);
         }
-        consumeKeywordToArgs(ctx, KEYWORDS$1.AND, args);
-        const secondArg = parseOneArgument(ctx, [KEYWORDS$1.FROM, KEYWORDS$1.ON, KEYWORDS$1.FOR]);
+        consumeKeywordToArgs(ctx, KEYWORDS.AND, args);
+        const secondArg = parseOneArgument(ctx, [KEYWORDS.FROM, KEYWORDS.ON, KEYWORDS.FOR]);
         if (secondArg) {
             args.push(secondArg);
         }
-        const preposition = consumeOneOfKeywordsToArgs(ctx, [KEYWORDS$1.FROM, KEYWORDS$1.ON], args);
+        const preposition = consumeOneOfKeywordsToArgs(ctx, [KEYWORDS.FROM, KEYWORDS.ON], args);
         if (preposition) {
             const targetArg = parseOneArgument(ctx);
             if (targetArg) {
@@ -3056,11 +2978,11 @@ function parseToggleCommand(ctx, identifierNode) {
             .endingAt(ctx.getPosition())
             .build();
     }
-    const classArg = parseOneArgument(ctx, [KEYWORDS$1.FROM, KEYWORDS$1.ON]);
+    const classArg = parseOneArgument(ctx, [KEYWORDS.FROM, KEYWORDS.ON]);
     if (classArg) {
         args.push(classArg);
     }
-    const preposition = consumeOneOfKeywordsToArgs(ctx, [KEYWORDS$1.FROM, KEYWORDS$1.ON], args);
+    const preposition = consumeOneOfKeywordsToArgs(ctx, [KEYWORDS.FROM, KEYWORDS.ON], args);
     if (preposition) {
         const targetArg = parseOneArgument(ctx);
         if (targetArg) {
@@ -3078,12 +3000,12 @@ function parseAddCommand(ctx, commandToken) {
         args.push(ctx.parseCSSObjectLiteral());
     }
     else {
-        const classArg = parseOneArgument(ctx, [KEYWORDS$1.TO]);
+        const classArg = parseOneArgument(ctx, [KEYWORDS.TO]);
         if (classArg) {
             args.push(classArg);
         }
     }
-    if (ctx.check(KEYWORDS$1.TO)) {
+    if (ctx.check(KEYWORDS.TO)) {
         ctx.advance();
         const targetArg = parseOneArgument(ctx);
         if (targetArg) {
@@ -3116,19 +3038,19 @@ function parsePutCommand(ctx, identifierNode) {
         operation = PUT_OPERATIONS.AT_END_OF;
     }
     else if (operation === PUT_OPERATIONS.AT) {
-        if (ctx.check(KEYWORDS$1.START) || ctx.check(KEYWORDS$1.THE)) {
-            consumeOptionalKeyword(ctx, KEYWORDS$1.THE);
-            if (ctx.check(KEYWORDS$1.START)) {
+        if (ctx.check(KEYWORDS.START) || ctx.check(KEYWORDS.THE)) {
+            consumeOptionalKeyword(ctx, KEYWORDS.THE);
+            if (ctx.check(KEYWORDS.START)) {
                 ctx.advance();
-                if (ctx.check(KEYWORDS$1.OF)) {
+                if (ctx.check(KEYWORDS.OF)) {
                     ctx.advance();
                     operation = PUT_OPERATIONS.AT_START_OF;
                 }
             }
         }
-        else if (ctx.check(KEYWORDS$1.END)) {
+        else if (ctx.check(KEYWORDS.END)) {
             ctx.advance();
-            if (ctx.check(KEYWORDS$1.OF)) {
+            if (ctx.check(KEYWORDS.OF)) {
                 ctx.advance();
                 operation = PUT_OPERATIONS.AT_END_OF;
             }
@@ -3178,7 +3100,7 @@ function parseSwapCommand(ctx, identifierNode) {
             .endingAt(ctx.getPosition())
             .build();
     }
-    if (!ctx.isAtEnd() && ctx.check(KEYWORDS$1.OF)) {
+    if (!ctx.isAtEnd() && ctx.check(KEYWORDS.OF)) {
         ctx.advance();
         args.push(ctx.createIdentifier('of'));
     }
@@ -3186,7 +3108,7 @@ function parseSwapCommand(ctx, identifierNode) {
     if (targetExpr) {
         args.push(targetExpr);
     }
-    if (!ctx.isAtEnd() && ctx.check(KEYWORDS$1.WITH)) {
+    if (!ctx.isAtEnd() && ctx.check(KEYWORDS.WITH)) {
         ctx.advance();
         args.push(ctx.createIdentifier('with'));
         const contentExpr = ctx.parseExpression();
@@ -3252,9 +3174,9 @@ function parseWaitCommand(ctx, commandToken) {
             }
         } while (!ctx.isAtEnd());
         let eventTarget = null;
-        if (ctx.check(KEYWORDS$1.FROM)) {
+        if (ctx.check(KEYWORDS.FROM)) {
             ctx.advance();
-            consumeOptionalKeyword(ctx, KEYWORDS$1.THE);
+            consumeOptionalKeyword(ctx, KEYWORDS.THE);
             eventTarget = ctx.parsePrimary();
         }
         const eventPos = {
@@ -3372,7 +3294,7 @@ function parseColonVariable(ctx) {
     };
 }
 function parseScopedVariable(ctx) {
-    if (!ctx.check(KEYWORDS$1.GLOBAL) && !ctx.check(KEYWORDS$1.LOCAL))
+    if (!ctx.check(KEYWORDS.GLOBAL) && !ctx.check(KEYWORDS.LOCAL))
         return null;
     const scopeToken = ctx.advance();
     const variableToken = ctx.advance();
@@ -3385,15 +3307,15 @@ function parseScopedVariable(ctx) {
     };
 }
 function parsePropertyOfTarget(ctx, startPosition) {
-    if (!ctx.check(KEYWORDS$1.THE))
+    if (!ctx.check(KEYWORDS.THE))
         return null;
     const thePosition = ctx.savePosition();
     ctx.advance();
     const nextToken = ctx.peek();
     const tokenAfterNext = ctx.peekAt(1);
-    if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS$1.OF) {
+    if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS.OF) {
         const propertyToken = ctx.advance();
-        if (ctx.check(KEYWORDS$1.OF)) {
+        if (ctx.check(KEYWORDS.OF)) {
             ctx.advance();
             const targetToken = ctx.advance();
             const isIdSelector = targetToken.value.startsWith('#');
@@ -3418,7 +3340,7 @@ function parsePropertyOfTarget(ctx, startPosition) {
         ctx.restorePosition(startPosition);
         return null;
     }
-    if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS$1.TO) {
+    if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS.TO) {
         const variableToken = ctx.advance();
         return {
             type: 'identifier',
@@ -3446,11 +3368,11 @@ function parseTargetFallback(ctx) {
     }
     const targetTokens = [];
     while (!ctx.isAtEnd() &&
-        !ctx.check(KEYWORDS$1.TO) &&
-        !ctx.check(KEYWORDS$1.THEN) &&
-        !ctx.check(KEYWORDS$1.AND) &&
-        !ctx.check(KEYWORDS$1.ELSE) &&
-        !ctx.check(KEYWORDS$1.END)) {
+        !ctx.check(KEYWORDS.TO) &&
+        !ctx.check(KEYWORDS.THEN) &&
+        !ctx.check(KEYWORDS.AND) &&
+        !ctx.check(KEYWORDS.ELSE) &&
+        !ctx.check(KEYWORDS.END)) {
         targetTokens.push(ctx.parsePrimary());
     }
     if (targetTokens.length === 0) {
@@ -3458,8 +3380,8 @@ function parseTargetFallback(ctx) {
     }
     if (targetTokens.length >= 4) {
         const nodeStr = (node, key) => node[key];
-        if (nodeStr(targetTokens[0], 'value') === KEYWORDS$1.THE &&
-            nodeStr(targetTokens[2], 'value') === KEYWORDS$1.OF) {
+        if (nodeStr(targetTokens[0], 'value') === KEYWORDS.THE &&
+            nodeStr(targetTokens[2], 'value') === KEYWORDS.OF) {
             const propToken = targetTokens[1];
             const targetToken = targetTokens[3];
             return {
@@ -3512,7 +3434,7 @@ function parseSetCommand(ctx, identifierNode) {
         targetExpression = fallback.expression;
         fallbackTokens = fallback.tokens;
     }
-    if (!ctx.check(KEYWORDS$1.TO)) {
+    if (!ctx.check(KEYWORDS.TO)) {
         const found = ctx.isAtEnd() ? 'end of input' : ctx.peek().value;
         throw new Error(`Expected 'to' in set command, found: ${found}`);
     }
@@ -3525,7 +3447,7 @@ function parseSetCommand(ctx, identifierNode) {
     else if (fallbackTokens.length > 0) {
         finalArgs.push(...fallbackTokens);
     }
-    finalArgs.push(ctx.createIdentifier(KEYWORDS$1.TO));
+    finalArgs.push(ctx.createIdentifier(KEYWORDS.TO));
     if (value) {
         finalArgs.push(value);
     }
@@ -3539,7 +3461,7 @@ function parseIncrementDecrementCommand(ctx, commandToken) {
     const isIncrement = commandName === 'increment';
     const operator = isIncrement ? '+' : '-';
     let hasGlobal = false;
-    if (ctx.check(KEYWORDS$1.GLOBAL)) {
+    if (ctx.check(KEYWORDS.GLOBAL)) {
         hasGlobal = true;
         ctx.advance();
     }
@@ -3548,7 +3470,7 @@ function parseIncrementDecrementCommand(ctx, commandToken) {
         throw new Error(`Expected variable or expression after ${commandName}`);
     }
     let amount;
-    if (ctx.check(KEYWORDS$1.BY)) {
+    if (ctx.check(KEYWORDS.BY)) {
         ctx.advance();
         const parsedAmount = ctx.parseExpression();
         if (!parsedAmount) {
@@ -3579,7 +3501,7 @@ function parseIncrementDecrementCommand(ctx, commandToken) {
         column: commandToken.column,
     };
     const binaryExpr = createBinaryExpression(operator, target, amount, pos);
-    const toIdentifier = createIdentifier(KEYWORDS$1.TO, pos);
+    const toIdentifier = createIdentifier(KEYWORDS.TO, pos);
     const args = [targetWithScope, toIdentifier, binaryExpr];
     return CommandNodeBuilder.from(commandToken)
         .withName('set')
@@ -3796,12 +3718,12 @@ function parseJsCommand(ctx, identifierNode) {
         ctx.consume(')', 'Expected ) after js parameters');
     }
     const jsCodeStart = ctx.peek().start;
-    while (!ctx.check(KEYWORDS$1.END) && !ctx.isAtEnd()) {
+    while (!ctx.check(KEYWORDS.END) && !ctx.isAtEnd()) {
         ctx.advance();
     }
     const endToken = ctx.peek();
     const jsCodeEnd = endToken.start;
-    ctx.consume(KEYWORDS$1.END, 'Expected end after js code body');
+    ctx.consume(KEYWORDS.END, 'Expected end after js code body');
     const rawSlice = ctx.getInputSlice(jsCodeStart, jsCodeEnd);
     const code = rawSlice.trim();
     const codeNode = {
@@ -3847,10 +3769,10 @@ function parseTellCommand(ctx, identifierNode) {
             catch {
                 break;
             }
-            if (ctx.match(KEYWORDS$1.AND)) {
+            if (ctx.match(KEYWORDS.AND)) {
                 continue;
             }
-            if (ctx.check(KEYWORDS$1.THEN) || ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
+            if (ctx.check(KEYWORDS.THEN) || ctx.check(KEYWORDS.ELSE) || ctx.check(KEYWORDS.END)) {
                 break;
             }
             if (ctx.checkIsCommand()) {
@@ -3871,6 +3793,292 @@ function parseTellCommand(ctx, identifierNode) {
         .build();
 }
 
+const STOP_TOKENS = new Set([
+    'then',
+    'end',
+    'to',
+    'into',
+    'on',
+    'with',
+    'from',
+    'in',
+    'by',
+    'for',
+    'while',
+    'until',
+    'unless',
+    'else',
+    'catch',
+    'finally',
+]);
+const STOP_DELIMITERS = new Set([')', ']', '}', ',']);
+function mergeFragments(...fragments) {
+    const merged = new Map();
+    for (const fragment of fragments) {
+        for (const [key, entry] of fragment) {
+            const existing = merged.get(key);
+            if (existing) {
+                merged.set(key, {
+                    prefix: entry.prefix ?? existing.prefix,
+                    infix: entry.infix ?? existing.infix,
+                });
+            }
+            else {
+                merged.set(key, { ...entry });
+            }
+        }
+    }
+    return merged;
+}
+function leftAssoc(bp, handler) {
+    return {
+        infix: {
+            bp: [bp, bp + 1],
+            handler: handler ??
+                ((left, token, ctx) => ({
+                    type: 'binaryExpression',
+                    operator: token.value,
+                    left,
+                    right: ctx.parseExpr(bp + 1),
+                    start: left.start,
+                })),
+        },
+    };
+}
+function rightAssoc(bp, handler) {
+    return {
+        infix: {
+            bp: [bp + 1, bp],
+            handler: ((left, token, ctx) => ({
+                    type: 'binaryExpression',
+                    operator: token.value,
+                    left,
+                    right: ctx.parseExpr(bp),
+                    start: left.start,
+                })),
+        },
+    };
+}
+function prefix(bp, handler) {
+    return {
+        prefix: {
+            bp,
+            handler: handler ??
+                ((token, ctx) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: ctx.parseExpr(bp),
+                    start: token.start,
+                })),
+        },
+    };
+}
+const CORE_FRAGMENT = new Map([
+    ['or', leftAssoc(10)],
+    ['||', leftAssoc(10)],
+    ['and', leftAssoc(20)],
+    ['&&', leftAssoc(20)],
+    ['==', leftAssoc(30)],
+    ['!=', leftAssoc(30)],
+    ['<', leftAssoc(30)],
+    ['>', leftAssoc(30)],
+    ['<=', leftAssoc(30)],
+    ['>=', leftAssoc(30)],
+    ['is', leftAssoc(30)],
+    ['matches', leftAssoc(30)],
+    ['contains', leftAssoc(30)],
+    ['+', { ...leftAssoc(40), ...prefix(80) }],
+    ['-', { ...leftAssoc(40), ...prefix(80) }],
+    ['*', leftAssoc(50)],
+    ['/', leftAssoc(50)],
+    ['%', leftAssoc(50)],
+    ['mod', leftAssoc(50)],
+    ['^', rightAssoc(60)],
+    ['**', rightAssoc(60)],
+    [
+        'as',
+        leftAssoc(70, (left, _token, ctx) => ({
+            type: 'asExpression',
+            expression: left,
+            targetType: ctx.parseExpr(71),
+            start: left.start,
+        })),
+    ],
+    ['not', prefix(80)],
+    ['!', prefix(80)],
+    ['no', prefix(80)],
+]);
+const POSITIONAL_FRAGMENT = new Map([
+    [
+        'first',
+        prefix(85, (token, ctx) => ({
+            type: 'positionalExpression',
+            position: 'first',
+            operand: ctx.parseExpr(85),
+            start: token.start,
+        })),
+    ],
+    [
+        'last',
+        prefix(85, (token, ctx) => ({
+            type: 'positionalExpression',
+            position: 'last',
+            operand: ctx.parseExpr(85),
+            start: token.start,
+        })),
+    ],
+]);
+const PROPERTY_FRAGMENT = new Map([
+    [
+        '.',
+        {
+            infix: {
+                bp: [90, 91],
+                handler: (left, _token, ctx) => {
+                    const propToken = ctx.advance();
+                    return {
+                        type: 'propertyAccess',
+                        object: left,
+                        property: propToken.value,
+                        start: left.start,
+                    };
+                },
+            },
+        },
+    ],
+    [
+        '?.',
+        {
+            infix: {
+                bp: [90, 91],
+                handler: (left, _token, ctx) => {
+                    const propToken = ctx.advance();
+                    return {
+                        type: 'optionalChain',
+                        object: left,
+                        property: propToken.value,
+                        start: left.start,
+                    };
+                },
+            },
+        },
+    ],
+    [
+        "'s",
+        {
+            infix: {
+                bp: [95, 96],
+                handler: (left, _token, ctx) => {
+                    const propToken = ctx.advance();
+                    return {
+                        type: 'possessiveExpression',
+                        object: left,
+                        property: propToken.value,
+                        start: left.start,
+                    };
+                },
+            },
+        },
+    ],
+]);
+const PARSER_COMPARISON_FRAGMENT = new Map([
+    ['===', leftAssoc(30)],
+    ['!==', leftAssoc(30)],
+    ['is not', leftAssoc(30)],
+    ['is a', leftAssoc(30)],
+    ['is an', leftAssoc(30)],
+    ['is not a', leftAssoc(30)],
+    ['is not an', leftAssoc(30)],
+    ['is in', leftAssoc(30)],
+    ['is not in', leftAssoc(30)],
+    ['has', leftAssoc(30)],
+    ['have', leftAssoc(30)],
+    ['match', leftAssoc(30)],
+    ['include', leftAssoc(30)],
+    ['includes', leftAssoc(30)],
+    ['equals', leftAssoc(30)],
+    ['does not contain', leftAssoc(30)],
+    ['does not include', leftAssoc(30)],
+    ['in', leftAssoc(30)],
+    ['of', leftAssoc(30)],
+    ['really', leftAssoc(30)],
+    [
+        'exists',
+        {
+            prefix: {
+                bp: 80,
+                handler: (token, ctx) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: ctx.parseExpr(80),
+                    start: token.start,
+                }),
+            },
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    [
+        'does not exist',
+        {
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    [
+        'is empty',
+        {
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    [
+        'is not empty',
+        {
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    ['some', prefix(80)],
+]);
+const ASSIGNMENT_FRAGMENT = new Map([
+    ['=', rightAssoc(5)],
+]);
+mergeFragments(CORE_FRAGMENT, POSITIONAL_FRAGMENT, PROPERTY_FRAGMENT);
+const PARSER_TABLE = mergeFragments(CORE_FRAGMENT, PARSER_COMPARISON_FRAGMENT, ASSIGNMENT_FRAGMENT);
+
 function parseTimeToMs(timeStr) {
     if (timeStr.endsWith('ms'))
         return parseInt(timeStr, 10);
@@ -3889,7 +4097,9 @@ function parseTimeToMs(timeStr) {
 class Parser {
     constructor(tokens, options, originalInput) {
         this.current = 0;
+        this.errors = [];
         this.warnings = [];
+        this.prattCache = new Map();
         this.tokens = tokens;
         this.keywordResolver = options?.keywords;
         this.registryIntegration = options?.registryIntegration;
@@ -3912,6 +4122,14 @@ class Parser {
         this.warnings.push(warning);
     }
     parse() {
+        this.prattCache.clear();
+        const result = this.parseInternal();
+        if (this.errors.length > 0) {
+            result.errors = [...this.errors];
+        }
+        return result;
+    }
+    parseInternal() {
         try {
             if (this.tokens.length === 0) {
                 this.addError('Cannot parse empty input');
@@ -4127,7 +4345,114 @@ class Parser {
         }
     }
     parseExpression() {
-        return this.parseAssignment();
+        return this.parseExpressionPratt(0);
+    }
+    parseExpressionPratt(minBp) {
+        const cacheKey = `${this.current}:${minBp}`;
+        const cached = this.prattCache.get(cacheKey);
+        if (cached) {
+            this.current = cached.endPos;
+            return cached.node;
+        }
+        this.current;
+        if (this.isAtEnd()) {
+            this.addError('Unexpected end of expression');
+            return this.createErrorNode();
+        }
+        const firstToken = this.peek();
+        const prefixEntry = Parser.PRATT_TABLE.get(firstToken.value);
+        let left;
+        if (prefixEntry?.prefix) {
+            const token = this.advance();
+            if (this.isAtEnd()) {
+                this.addError(`Expected expression after '${token.value}' operator`);
+                return this.createErrorNode();
+            }
+            left = prefixEntry.prefix.handler(token, this.makePrattContext());
+        }
+        else {
+            left = this.parseCall();
+        }
+        while (!this.isAtEnd()) {
+            const nextToken = this.peek();
+            const infixEntry = Parser.PRATT_TABLE.get(nextToken.value);
+            if (!infixEntry?.infix) {
+                if (STOP_TOKENS.has(nextToken.value) || STOP_DELIMITERS.has(nextToken.value)) {
+                    break;
+                }
+                break;
+            }
+            const [leftBp] = infixEntry.infix.bp;
+            if (leftBp < minBp)
+                break;
+            if (nextToken.value === '=') {
+                if (this.current + 1 < this.tokens.length && this.tokens[this.current + 1].value === '>') {
+                    this.advance();
+                    this.advance();
+                    this.addError('Arrow functions (=>) are not supported in hyperscript. ' +
+                        'Use "js ... end" blocks for JavaScript callbacks.');
+                    if (!this.isAtEnd()) {
+                        try {
+                            this.parseExpressionPratt(0);
+                        }
+                        catch {
+                        }
+                    }
+                    return this.createErrorNode();
+                }
+            }
+            if (nextToken.value === '+' || nextToken.value === '-') {
+                const afterOp = this.current + 1 < this.tokens.length ? this.tokens[this.current + 1] : null;
+                if (afterOp && (afterOp.value === '+' || afterOp.value === '-')) {
+                    this.addError(`Invalid operator combination: ${nextToken.value}${afterOp.value}`);
+                    return left;
+                }
+            }
+            if (nextToken.value === '*' || nextToken.value === '/' || nextToken.value === '%') {
+                const afterOp = this.current + 1 < this.tokens.length ? this.tokens[this.current + 1] : null;
+                if (afterOp &&
+                    (afterOp.value === '*' ||
+                        afterOp.value === '/' ||
+                        afterOp.value === '%' ||
+                        afterOp.value === '+' ||
+                        afterOp.value === '-')) {
+                    if (nextToken.value === '*' && afterOp.value === '*') {
+                        this.addError(`Unexpected token: ${afterOp.value}`);
+                    }
+                    else {
+                        this.addError(`Invalid operator combination: ${nextToken.value}${afterOp.value}`);
+                    }
+                    return left;
+                }
+            }
+            const opToken = this.advance();
+            if (this.isAtEnd() && !Parser.POSTFIX_UNARY_OPERATORS.has(opToken.value)) {
+                this.addError(`Expected expression after '${opToken.value}' operator`);
+                return left;
+            }
+            left = infixEntry.infix.handler(left, opToken, this.makePrattContext());
+        }
+        this.prattCache.set(cacheKey, { node: left, endPos: this.current });
+        return left;
+    }
+    makePrattContext() {
+        const self = this;
+        return {
+            peek: () => (self.current < self.tokens.length ? self.tokens[self.current] : undefined),
+            advance: () => {
+                const token = self.tokens[self.current];
+                self.current++;
+                return token;
+            },
+            parseExpr: (bp) => self.parseExpressionPratt(bp),
+            isStopToken: () => {
+                const t = self.tokens[self.current];
+                if (!t)
+                    return true;
+                return STOP_TOKENS.has(t.value) || STOP_DELIMITERS.has(t.value);
+            },
+            atEnd: () => self.current >= self.tokens.length,
+        };
     }
     parseAssignment() {
         let expr = this.parseLogicalOr();
@@ -4744,6 +5069,17 @@ class Parser {
             if (token.value === 'the') {
                 return this.parseTheXofY();
             }
+            if (token.value === 'values' && this.check('of')) {
+                this.advance();
+                const target = this.parsePrimary();
+                return {
+                    type: 'propertyOfExpression',
+                    property: { type: 'identifier', name: 'values' },
+                    target,
+                    line: token.line,
+                    column: token.column,
+                };
+            }
             return this.createIdentifier(token.value);
         }
         if (this.match('$')) {
@@ -5549,36 +5885,7 @@ class Parser {
                         }
                     }
                 }
-                const handlerCommands = [];
-                while (!this.isAtEnd() && !this.check('end')) {
-                    if (this.checkIsCommand() || this.isCommand(this.peek().value)) {
-                        this.advance();
-                        const savedError = this.error;
-                        try {
-                            const cmd = this.parseCommand();
-                            if (this.error && this.error !== savedError) {
-                                this.error = savedError;
-                            }
-                            handlerCommands.push(cmd);
-                            while (!this.isAtEnd() &&
-                                !this.check('end') &&
-                                !this.checkIsCommand() &&
-                                !this.isCommand(this.peek().value)) {
-                                this.advance();
-                            }
-                        }
-                        catch (error) {
-                            this.error = savedError;
-                            break;
-                        }
-                    }
-                    else {
-                        if (!this.check('end')) {
-                            this.addError(`Unexpected token in event handler: ${this.peek().value}`);
-                        }
-                        break;
-                    }
-                }
+                const handlerCommands = this.parseCommandListUntilEnd();
                 const handlerNode = {
                     type: 'eventHandler',
                     event: eventName,
@@ -5591,7 +5898,6 @@ class Parser {
                     column: handlerPos.column,
                 };
                 eventHandlers.push(handlerNode);
-                this.consume('end', "Expected 'end' after event handler body");
             }
             else if (this.match('init')) {
                 const initCommands = this.parseCommandBlock(['end']);
@@ -5665,7 +5971,23 @@ class Parser {
                 break;
             }
             else {
-                this.addError(`Expected command, got: ${this.peek().value}`);
+                const errorToken = this.peek();
+                const errorPos = this.getPosition();
+                const errorMessage = `Expected command, got: ${errorToken.value}`;
+                this.addError(errorMessage);
+                const errorNode = createErrorCommandNode(errorPos, errorMessage, errorToken.value);
+                commands.push(errorNode);
+                this.synchronizeToCommandBoundary();
+                if (this.isAtEnd())
+                    break;
+                if (this.match('then'))
+                    continue;
+                if (this.check('end') || this.check('on'))
+                    break;
+                if (this.checkIsCommand() ||
+                    (this.isCommand(this.peek().value) && !this.isKeyword(this.peek().value))) {
+                    continue;
+                }
                 break;
             }
         }
@@ -6296,6 +6618,20 @@ class Parser {
             column: Math.max(1, column),
             position: Math.max(0, position),
         };
+        this.errors.push(this.error);
+    }
+    synchronizeToCommandBoundary() {
+        while (!this.isAtEnd()) {
+            const token = this.peek();
+            if (token.value === 'then' || token.value === 'end' || token.value === 'on') {
+                return;
+            }
+            if (this.checkIsCommand() || (this.isCommand(token.value) && !this.isKeyword(token.value))) {
+                return;
+            }
+            debug.parse('⚠️  synchronize: Skipping token:', token.value);
+            this.advance();
+        }
     }
     parseAttributeOrArrayLiteral() {
         const startPos = this.previous().start;
@@ -6446,6 +6782,7 @@ Parser.POSTFIX_UNARY_OPERATORS = new Set([
     'is empty',
     'is not empty',
 ]);
+Parser.PRATT_TABLE = PARSER_TABLE;
 Parser.PSEUDO_COMMAND_PREPOSITIONS = ['from', 'on', 'with', 'into', 'at', 'to'];
 
 class FullParserImpl {