@hyperfixi/core 2.3.0 → 2.4.0

package/dist/parser/full-parser.js

@@ -40,19 +40,26 @@ const COMMANDS = new Set([
     'append',
     'async',
     'beep',
+    'blur',
     'break',
+    'breakpoint',
     'call',
+    'clear',
+    'close',
     'continue',
     'copy',
     'decrement',
     'default',
+    'empty',
     'exit',
     'fetch',
+    'focus',
     'for',
     'get',
     'go',
     'halt',
     'hide',
+    'open',
     'if',
     'increment',
     'install',
@@ -69,11 +76,15 @@ const COMMANDS = new Set([
     'render',
     'repeat',
     'replace',
+    'reset',
     'return',
+    'scroll',
+    'select',
     'send',
     'set',
     'settle',
     'show',
+    'start',
     'swap',
     'take',
     'tell',
@@ -99,6 +110,8 @@ const COMPOUND_COMMANDS = new Set([
     'measure',
     'js',
     'tell',
+    'pick',
+    'start',
     'swap',
     'morph',
     'push',
@@ -217,11 +230,20 @@ const COMPARISON_OPERATORS = new Set([
     '>=',
     'is',
     'is not',
+    'am',
     'is a',
     'is an',
     'is not a',
     'is not an',
+    'precedes',
+    'does not precede',
+    'follows',
+    'does not follow',
     'contains',
+    'starts with',
+    'ends with',
+    'does not start with',
+    'does not end with',
     'has',
     'have',
     'does not contain',
@@ -236,6 +258,8 @@ const COMPARISON_OPERATORS = new Set([
     'is not empty',
     'is in',
     'is not in',
+    'is between',
+    'is not between',
     'equals',
     'in',
     'is equal to',
@@ -247,6 +271,11 @@ const COMPARISON_OPERATORS = new Set([
     'is greater than or equal to',
     'is less than or equal to',
     'really equals',
+    'ignoring case',
+    'sorted by',
+    'mapped to',
+    'split by',
+    'joined by',
 ]);
 const DOM_EVENTS = new Set([
     'click',
@@ -1786,205 +1815,639 @@ SemanticIntegrationAdapter.SKIP_SEMANTIC_COMMANDS = new Set([
     'tell',
 ]);
 
-function isCommand(token) {
-    if (token.kind !== TokenKind.IDENTIFIER)
-        return false;
-    return COMMANDS.has(token.value.toLowerCase());
-}
-function isKeyword$1(token) {
-    if (token.kind !== TokenKind.IDENTIFIER)
-        return false;
-    return TOKENIZER_KEYWORDS.has(token.value.toLowerCase());
-}
-function isEvent(token) {
-    if (token.kind !== TokenKind.IDENTIFIER)
-        return false;
-    return DOM_EVENTS.has(token.value.toLowerCase());
-}
-function isContextVar(token) {
-    if (token.kind !== TokenKind.IDENTIFIER)
-        return false;
-    return CONTEXT_VARS.has(token.value.toLowerCase());
-}
-function isComparisonOperator(token) {
-    if (token.kind === TokenKind.OPERATOR) {
-        return COMPARISON_OPERATORS.has(token.value.toLowerCase());
-    }
-    return COMPARISON_OPERATORS.has(token.value.toLowerCase());
-}
-function isIdentifierLike(token) {
-    return token.kind === TokenKind.IDENTIFIER;
-}
-function isSelector(token) {
-    return token.kind === TokenKind.SELECTOR;
-}
-function isBasicSelector(token) {
-    if (token.kind !== TokenKind.SELECTOR)
-        return false;
-    return !token.value.startsWith('<');
-}
-function isLiteral(token) {
-    return (token.kind === TokenKind.STRING ||
-        token.kind === TokenKind.NUMBER ||
-        token.kind === TokenKind.TEMPLATE);
-}
-function isReference(token) {
-    return token.kind === TokenKind.IDENTIFIER;
-}
-function isTimeExpression(token) {
-    return token.kind === TokenKind.TIME;
-}
-function isSymbol(token) {
-    return token.kind === TokenKind.SYMBOL;
-}
-function isComment(token) {
-    return token.kind === TokenKind.COMMENT;
-}
-function isIdentifier(token) {
-    if (token.kind !== TokenKind.IDENTIFIER)
-        return false;
-    const lowerValue = token.value.toLowerCase();
-    return (!COMMANDS.has(lowerValue) &&
-        !TOKENIZER_KEYWORDS.has(lowerValue) &&
-        !DOM_EVENTS.has(lowerValue) &&
-        !CONTEXT_VARS.has(lowerValue));
-}
-function isString(token) {
-    return token.kind === TokenKind.STRING;
-}
-function isNumber(token) {
-    return token.kind === TokenKind.NUMBER;
-}
-function isBoolean(token) {
-    if (token.kind === TokenKind.IDENTIFIER) {
-        const v = token.value;
-        return v === 'true' || v === 'false' || v === 'null' || v === 'undefined';
+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 false;
-}
-function isTemplateLiteral(token) {
-    return token.kind === TokenKind.TEMPLATE;
-}
-function isQueryReference(token) {
-    return token.kind === TokenKind.SELECTOR && token.value.startsWith('<');
-}
-function isIdSelector(token) {
-    return token.kind === TokenKind.SELECTOR && token.value.startsWith('#');
-}
-function isClassSelector(token) {
-    return token.kind === TokenKind.SELECTOR && token.value.startsWith('.');
-}
-function isCssSelector(token) {
-    if (token.kind !== TokenKind.SELECTOR)
-        return false;
-    return !token.value.startsWith('#') && !token.value.startsWith('.');
-}
-function isBasicOperator(token) {
-    if (token.kind !== TokenKind.OPERATOR)
-        return false;
-    const lowerValue = token.value.toLowerCase();
-    return !LOGICAL_OPERATORS.has(lowerValue) && !COMPARISON_OPERATORS.has(lowerValue);
-}
-function isCommandTerminator(token) {
-    const value = token.value.toLowerCase();
-    return (value === 'then' || value === 'and' || value === 'else' || value === 'end' || value === 'on');
-}
-
-function createLiteral(value, raw, pos) {
-    return {
-        type: 'literal',
-        value,
-        raw,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
-    };
-}
-function createIdentifier(name, pos) {
-    return {
-        type: 'identifier',
-        name,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
-    };
-}
-function createBinaryExpression(operator, left, right, pos) {
-    return {
-        type: 'binaryExpression',
-        operator,
-        left,
-        right,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
-    };
-}
-function createUnaryExpression(operator, argument, prefix, pos) {
-    return {
-        type: 'unaryExpression',
-        operator,
-        argument,
-        prefix,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
-    };
-}
-function createCallExpression(callee, args, pos) {
-    return {
-        type: 'callExpression',
-        callee,
-        arguments: args,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
-    };
+    return merged;
 }
-function createMemberExpression(object, property, computed, pos) {
+function leftAssoc(bp, handler) {
     return {
-        type: 'memberExpression',
-        object,
-        property,
-        computed,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
+        infix: {
+            bp: [bp, bp + 1],
+            handler: handler ??
+                ((left, token, ctx) => {
+                    const right = ctx.parseExpr(bp + 1);
+                    return {
+                        type: 'binaryExpression',
+                        operator: token.value,
+                        left,
+                        right,
+                        start: left.start,
+                        end: right.end ?? token.end,
+                        line: left.line ?? token.line,
+                        column: left.column ?? token.column,
+                    };
+                }),
+        },
     };
 }
-function createSelector(value, pos) {
+function rightAssoc(bp, handler) {
     return {
-        type: 'selector',
-        value,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
+        infix: {
+            bp: [bp + 1, bp],
+            handler: ((left, token, ctx) => {
+                    const right = ctx.parseExpr(bp);
+                    return {
+                        type: 'binaryExpression',
+                        operator: token.value,
+                        left,
+                        right,
+                        start: left.start,
+                        end: right.end ?? token.end,
+                        line: left.line ?? token.line,
+                        column: left.column ?? token.column,
+                    };
+                }),
+        },
     };
 }
-function createPossessiveExpression(object, property, pos) {
+function prefix(bp, handler) {
     return {
-        type: 'possessiveExpression',
-        object,
-        property,
-        start: pos.start,
-        end: pos.end,
-        line: pos.line,
-        column: pos.column,
+        prefix: {
+            bp,
+            handler: handler ??
+                ((token, ctx) => {
+                    const operand = ctx.parseExpr(bp);
+                    return {
+                        type: 'unaryExpression',
+                        operator: token.value,
+                        operand,
+                        argument: operand,
+                        prefix: true,
+                        start: token.start,
+                        end: operand.end ?? token.end,
+                        line: token.line,
+                        column: token.column,
+                    };
+                }),
+        },
     };
 }
-function createBlock(commands, pos) {
-    return {
-        type: 'block',
-        commands,
-        start: pos.start,
-        end: pos.end,
+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)],
+    ['starts with', leftAssoc(30)],
+    ['ends with', leftAssoc(30)],
+    ['does not start with', leftAssoc(30)],
+    ['does not end with', leftAssoc(30)],
+    [
+        'is between',
+        leftAssoc(30, (left, _token, ctx) => {
+            const min = ctx.parseExpr(31);
+            const next = ctx.peek();
+            if (!next || next.value.toLowerCase() !== 'and') {
+                throw new Error(`between requires 'and' between min and max operands, got: ${next?.value ?? '<end>'}`);
+            }
+            ctx.advance();
+            const max = ctx.parseExpr(31);
+            return {
+                type: 'betweenExpression',
+                value: left,
+                min,
+                max,
+                negated: false,
+                start: left.start,
+                end: max.end,
+            };
+        }),
+    ],
+    [
+        'is not between',
+        leftAssoc(30, (left, _token, ctx) => {
+            const min = ctx.parseExpr(31);
+            const next = ctx.peek();
+            if (!next || next.value.toLowerCase() !== 'and') {
+                throw new Error(`between requires 'and' between min and max operands, got: ${next?.value ?? '<end>'}`);
+            }
+            ctx.advance();
+            const max = ctx.parseExpr(31);
+            return {
+                type: 'betweenExpression',
+                value: left,
+                min,
+                max,
+                negated: true,
+                start: left.start,
+                end: max.end,
+            };
+        }),
+    ],
+    [
+        'ignoring case',
+        {
+            infix: {
+                bp: [25, 26],
+                handler: (left, _token, _ctx) => {
+                    left.ignoringCase = true;
+                    return left;
+                },
+            },
+        },
+    ],
+    [
+        'where',
+        leftAssoc(28, (left, _token, ctx) => {
+            const predicate = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'where',
+                collection: left,
+                right: predicate,
+                start: left.start,
+                end: predicate.end,
+            };
+        }),
+    ],
+    [
+        'sorted by',
+        leftAssoc(28, (left, _token, ctx) => {
+            const keyExpr = ctx.parseExpr(29);
+            let order = 'asc';
+            const next = ctx.peek();
+            if (next && typeof next.value === 'string') {
+                const v = next.value.toLowerCase();
+                if (v === 'asc' || v === 'ascending') {
+                    ctx.advance();
+                    order = 'asc';
+                }
+                else if (v === 'desc' || v === 'descending') {
+                    ctx.advance();
+                    order = 'desc';
+                }
+            }
+            return {
+                type: 'collectionExpression',
+                operator: 'sorted by',
+                collection: left,
+                right: keyExpr,
+                order,
+                start: left.start,
+                end: keyExpr.end,
+            };
+        }),
+    ],
+    [
+        'mapped to',
+        leftAssoc(28, (left, _token, ctx) => {
+            const expr = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'mapped to',
+                collection: left,
+                right: expr,
+                start: left.start,
+                end: expr.end,
+            };
+        }),
+    ],
+    [
+        'split by',
+        leftAssoc(28, (left, _token, ctx) => {
+            const sep = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'split by',
+                collection: left,
+                right: sep,
+                start: left.start,
+                end: sep.end,
+            };
+        }),
+    ],
+    [
+        'joined by',
+        leftAssoc(28, (left, _token, ctx) => {
+            const sep = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'joined by',
+                collection: left,
+                right: sep,
+                start: left.start,
+                end: sep.end,
+            };
+        }),
+    ],
+    ['+', { ...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) => {
+            const targetType = ctx.parseExpr(71);
+            const peeked = ctx.peek();
+            if (peeked &&
+                peeked.value === ':' &&
+                targetType &&
+                targetType.type === 'identifier') {
+                ctx.advance();
+                const suffix = ctx.advance();
+                if (suffix && suffix.value !== undefined) {
+                    targetType.name = `${targetType.name}:${suffix.value}`;
+                    targetType.end = suffix.end;
+                }
+            }
+            return {
+                type: 'asExpression',
+                expression: left,
+                targetType,
+                start: left.start,
+                end: targetType.end ?? token.end,
+                line: left.line ?? token.line,
+                column: left.column ?? token.column,
+            };
+        }),
+    ],
+    ['not', prefix(80)],
+    ['!', prefix(80)],
+    ['no', prefix(80)],
+]);
+function makeTypeCheckHandler(negated) {
+    return (left, _token, ctx) => {
+        const typeToken = ctx.advance();
+        if (!typeToken || !typeToken.value) {
+            throw new Error(`Type check requires a type name after 'is ${negated ? 'not ' : ''}a/an', got: <end>`);
+        }
+        let nullOk = true;
+        const peeked = ctx.peek();
+        if (peeked && peeked.value === '!') {
+            ctx.advance();
+            nullOk = false;
+        }
+        return {
+            type: 'typeCheckExpression',
+            value: left,
+            typeName: typeToken.value,
+            nullOk,
+            negated,
+            start: left.start,
+            end: typeToken.end,
+        };
+    };
+}
+const PARSER_COMPARISON_FRAGMENT = new Map([
+    ['===', leftAssoc(30)],
+    ['!==', leftAssoc(30)],
+    ['is not', leftAssoc(30)],
+    ['am', leftAssoc(30)],
+    ['is in', leftAssoc(30)],
+    ['is not in', leftAssoc(30)],
+    ['precedes', leftAssoc(30)],
+    ['does not precede', leftAssoc(30)],
+    ['follows', leftAssoc(30)],
+    ['does not follow', leftAssoc(30)],
+    ['is a', leftAssoc(30, makeTypeCheckHandler(false))],
+    ['is an', leftAssoc(30, makeTypeCheckHandler(false))],
+    ['is not a', leftAssoc(30, makeTypeCheckHandler(true))],
+    ['is not an', leftAssoc(30, makeTypeCheckHandler(true))],
+    ['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)],
+    ['is equal to', leftAssoc(30)],
+    ['is not equal to', leftAssoc(30)],
+    ['is really equal to', leftAssoc(30)],
+    ['is not really equal to', leftAssoc(30)],
+    ['really equals', leftAssoc(30)],
+    ['is greater than', leftAssoc(30)],
+    ['is less than', leftAssoc(30)],
+    ['is greater than or equal to', leftAssoc(30)],
+    ['is less than or equal to', 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)],
+]);
+const PARSER_TABLE = mergeFragments(CORE_FRAGMENT, PARSER_COMPARISON_FRAGMENT, ASSIGNMENT_FRAGMENT);
+
+const FEATURE_REGISTRY = new Map();
+function getRegisteredFeature(name) {
+    return FEATURE_REGISTRY.get(name.toLowerCase());
+}
+
+function isCommand(token) {
+    if (token.kind !== TokenKind.IDENTIFIER)
+        return false;
+    return COMMANDS.has(token.value.toLowerCase());
+}
+function isKeyword$1(token) {
+    if (token.kind !== TokenKind.IDENTIFIER)
+        return false;
+    return TOKENIZER_KEYWORDS.has(token.value.toLowerCase());
+}
+function isEvent(token) {
+    if (token.kind !== TokenKind.IDENTIFIER)
+        return false;
+    return DOM_EVENTS.has(token.value.toLowerCase());
+}
+function isContextVar(token) {
+    if (token.kind !== TokenKind.IDENTIFIER)
+        return false;
+    return CONTEXT_VARS.has(token.value.toLowerCase());
+}
+function isComparisonOperator(token) {
+    if (token.kind === TokenKind.OPERATOR) {
+        return COMPARISON_OPERATORS.has(token.value.toLowerCase());
+    }
+    return COMPARISON_OPERATORS.has(token.value.toLowerCase());
+}
+function isIdentifierLike(token) {
+    return token.kind === TokenKind.IDENTIFIER;
+}
+function isSelector(token) {
+    return token.kind === TokenKind.SELECTOR;
+}
+function isBasicSelector(token) {
+    if (token.kind !== TokenKind.SELECTOR)
+        return false;
+    return !token.value.startsWith('<');
+}
+function isLiteral(token) {
+    return (token.kind === TokenKind.STRING ||
+        token.kind === TokenKind.NUMBER ||
+        token.kind === TokenKind.TEMPLATE);
+}
+function isReference(token) {
+    return token.kind === TokenKind.IDENTIFIER;
+}
+function isTimeExpression(token) {
+    return token.kind === TokenKind.TIME;
+}
+function isSymbol(token) {
+    return token.kind === TokenKind.SYMBOL;
+}
+function isComment(token) {
+    return token.kind === TokenKind.COMMENT;
+}
+function isIdentifier(token) {
+    if (token.kind !== TokenKind.IDENTIFIER)
+        return false;
+    const lowerValue = token.value.toLowerCase();
+    return (!COMMANDS.has(lowerValue) &&
+        !TOKENIZER_KEYWORDS.has(lowerValue) &&
+        !DOM_EVENTS.has(lowerValue) &&
+        !CONTEXT_VARS.has(lowerValue));
+}
+function isString(token) {
+    return token.kind === TokenKind.STRING;
+}
+function isNumber(token) {
+    return token.kind === TokenKind.NUMBER;
+}
+function isBoolean(token) {
+    if (token.kind === TokenKind.IDENTIFIER) {
+        const v = token.value;
+        return v === 'true' || v === 'false' || v === 'null' || v === 'undefined';
+    }
+    return false;
+}
+function isTemplateLiteral(token) {
+    return token.kind === TokenKind.TEMPLATE;
+}
+function isQueryReference(token) {
+    return token.kind === TokenKind.SELECTOR && token.value.startsWith('<');
+}
+function isIdSelector(token) {
+    return token.kind === TokenKind.SELECTOR && token.value.startsWith('#');
+}
+function isClassSelector(token) {
+    return token.kind === TokenKind.SELECTOR && token.value.startsWith('.');
+}
+function isCssSelector(token) {
+    if (token.kind !== TokenKind.SELECTOR)
+        return false;
+    return !token.value.startsWith('#') && !token.value.startsWith('.');
+}
+function isBasicOperator(token) {
+    if (token.kind !== TokenKind.OPERATOR)
+        return false;
+    const lowerValue = token.value.toLowerCase();
+    return !LOGICAL_OPERATORS.has(lowerValue) && !COMPARISON_OPERATORS.has(lowerValue);
+}
+function isCommandTerminator(token) {
+    const value = token.value.toLowerCase();
+    return (value === 'then' || value === 'and' || value === 'else' || value === 'end' || value === 'on');
+}
+
+function createLiteral(value, raw, pos) {
+    return {
+        type: 'literal',
+        value,
+        raw,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createIdentifier(name, pos) {
+    return {
+        type: 'identifier',
+        name,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createBinaryExpression(operator, left, right, pos) {
+    return {
+        type: 'binaryExpression',
+        operator,
+        left,
+        right,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createUnaryExpression(operator, argument, prefix, pos) {
+    return {
+        type: 'unaryExpression',
+        operator,
+        argument,
+        prefix,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createCallExpression(callee, args, pos) {
+    return {
+        type: 'callExpression',
+        callee,
+        arguments: args,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createMemberExpression(object, property, computed, pos) {
+    return {
+        type: 'memberExpression',
+        object,
+        property,
+        computed,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createSelector(value, pos) {
+    return {
+        type: 'selector',
+        value,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createPossessiveExpression(object, property, pos) {
+    return {
+        type: 'possessiveExpression',
+        object,
+        property,
+        start: pos.start,
+        end: pos.end,
+        line: pos.line,
+        column: pos.column,
+    };
+}
+function createBlock(commands, pos) {
+    return {
+        type: 'block',
+        commands,
+        start: pos.start,
+        end: pos.end,
         line: pos.line,
         column: pos.column,
     };
@@ -2070,6 +2533,18 @@ function createErrorCommandNode(pos, message, source) {
         column: pos.column,
     };
 }
+function createPartialCommandNode(name, pos) {
+    return {
+        type: 'command',
+        name,
+        args: [],
+        partial: true,
+        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) {
@@ -2182,6 +2657,23 @@ function consumeOptionalKeyword(ctx, keyword) {
     }
     return false;
 }
+function parseMaybeNamedArgument(ctx) {
+    const checkpoint = ctx.savePosition();
+    let name;
+    if (ctx.checkIdentifierLike()) {
+        const possible = ctx.peek().value;
+        ctx.advance();
+        if (ctx.check(':')) {
+            ctx.advance();
+            name = possible;
+        }
+        else {
+            ctx.restorePosition(checkpoint);
+        }
+    }
+    const value = ctx.parseExpression();
+    return name !== undefined ? { name, value } : { value };
+}
 
 class CommandNodeBuilder {
     constructor(name) {
@@ -2329,26 +2821,13 @@ function parseTriggerCommand(ctx, identifierNode) {
             ctx.advance();
             const detailArgs = [];
             while (!ctx.isAtEnd() && !ctx.check(')')) {
-                const checkpoint = ctx.savePosition();
-                let paramName;
-                if (ctx.checkIdentifierLike()) {
-                    const possibleName = ctx.peek().value;
-                    ctx.advance();
-                    if (ctx.check(':')) {
-                        ctx.advance();
-                        paramName = possibleName;
-                    }
-                    else {
-                        ctx.restorePosition(checkpoint);
-                    }
-                }
-                const value = ctx.parseExpression();
-                if (paramName !== undefined) {
+                const { name, value } = parseMaybeNamedArgument(ctx);
+                if (name !== undefined) {
                     detailArgs.push({
                         type: 'objectLiteral',
                         properties: [
                             {
-                                key: { type: 'identifier', name: paramName },
+                                key: { type: 'identifier', name },
                                 value: value,
                             },
                         ],
@@ -2393,12 +2872,13 @@ function parseTriggerCommand(ctx, identifierNode) {
         }
     }
     const finalArgs = [...allArgs];
-    if (ctx.check('on') || ctx.check('to')) {
-        const keyword = ctx.advance().value;
-        finalArgs.push(ctx.createIdentifier(keyword));
-        while (!isCommandBoundary(ctx)) {
-            finalArgs.push(ctx.parsePrimary());
+    while (!isCommandBoundary(ctx)) {
+        if (ctx.check('on') || ctx.check('to')) {
+            const keyword = ctx.advance().value;
+            finalArgs.push(ctx.createIdentifier(keyword));
+            continue;
         }
+        finalArgs.push(ctx.parsePrimary());
     }
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...finalArgs)
@@ -2543,7 +3023,35 @@ function parseRepeatCommand(ctx, commandToken) {
             indexVariable = KEYWORDS.INDEX;
         }
     }
-    const commands = ctx.parseCommandListUntilEnd();
+    let commands;
+    let elseCommands = null;
+    let bottomTested = false;
+    if (loopType === KEYWORDS.FOREVER) {
+        const result = ctx.parseRepeatBody();
+        commands = result.commands;
+        if (result.terminator === 'else') {
+            ctx.advance();
+            elseCommands = ctx.parseCommandListUntilEnd();
+        }
+        else if (result.terminator === 'until' || result.terminator === 'while') {
+            bottomTested = true;
+            loopType = result.terminator;
+            ctx.advance();
+            condition = ctx.parseExpression();
+            if (!ctx.check('end')) {
+                throw new Error('Expected "end" to close repeat block');
+            }
+            ctx.advance();
+        }
+    }
+    else {
+        const result = ctx.parseCommandListUntilEndOrElse();
+        commands = result.commands;
+        if (result.hasElse) {
+            ctx.advance();
+            elseCommands = ctx.parseCommandListUntilEnd();
+        }
+    }
     args.push({
         type: 'identifier',
         name: loopType,
@@ -2575,11 +3083,19 @@ function parseRepeatCommand(ctx, commandToken) {
     if (indexVariable) {
         args.push(createStringLiteral(indexVariable, pos));
     }
-    args.push(createBlock(commands, { ...pos, end: pos.end || 0 }));
-    return CommandNodeBuilder.from(commandToken)
-        .withArgs(...args)
-        .endingAt(ctx.getPosition())
-        .build();
+    args.push(createBlock(commands, { ...pos, end: pos.end || 0 }));
+    if (elseCommands !== null) {
+        args.push(createBlock(elseCommands, { ...pos, end: pos.end || 0 }));
+    }
+    const builder = CommandNodeBuilder.from(commandToken).withArgs(...args);
+    if (bottomTested) {
+        builder.withModifier('bottomTested', {
+            type: 'literal',
+            value: true,
+            ...pos,
+        });
+    }
+    return builder.endingAt(ctx.getPosition()).build();
 }
 function parseIfCommand(ctx, commandToken) {
     const args = [];
@@ -2930,6 +3446,25 @@ function parseTransitionCommand(ctx, commandToken) {
         .endingAt(ctx.getPosition())
         .build();
 }
+function parseStartCommand(ctx, identifierNode) {
+    if (!ctx.match('view')) {
+        throw new Error("start: expected 'view transition' (only `start view transition ... end` is supported)");
+    }
+    if (!ctx.match('transition')) {
+        throw new Error("start view: expected 'transition'");
+    }
+    const modifiers = {};
+    if (ctx.match('using')) {
+        const nameExpr = ctx.parsePrimary();
+        modifiers.transitionName = nameExpr;
+    }
+    const body = ctx.parseCommandListUntilEnd();
+    return CommandNodeBuilder.fromIdentifier(identifierNode)
+        .withArgs(...body)
+        .withModifiers(modifiers)
+        .endingAt(ctx.getPosition())
+        .build();
+}
 
 function parseRemoveCommand(ctx, identifierNode) {
     const args = [];
@@ -3071,7 +3606,6 @@ const SWAP_STRATEGY_KEYWORDS = [
     'morphouter',
 ];
 function parseSwapCommand(ctx, identifierNode) {
-    console.log('[PARSER DEBUG] parseSwapCommand called');
     const args = [];
     let strategyKeyword = null;
     if (!ctx.isAtEnd()) {
@@ -3222,21 +3756,7 @@ function parseInstallCommand(ctx, commandToken) {
         ctx.advance();
         const params = [];
         while (!ctx.isAtEnd() && !ctx.check(')')) {
-            const checkpoint = ctx.savePosition();
-            let paramName;
-            if (ctx.checkIdentifierLike()) {
-                const possibleName = ctx.peek().value;
-                ctx.advance();
-                if (ctx.check(':')) {
-                    ctx.advance();
-                    paramName = possibleName;
-                }
-                else {
-                    ctx.restorePosition(checkpoint);
-                }
-            }
-            const value = ctx.parseExpression();
-            params.push(paramName !== undefined ? { name: paramName, value } : { value });
+            params.push(parseMaybeNamedArgument(ctx));
             if (ctx.check(',')) {
                 ctx.advance();
             }
@@ -3514,6 +4034,10 @@ function parseCompoundCommand(ctx, identifierNode) {
             return parseJsCommand(ctx, identifierNode);
         case 'tell':
             return parseTellCommand(ctx, identifierNode);
+        case 'pick':
+            return parsePickCommand(ctx, identifierNode);
+        case 'start':
+            return parseStartCommand(ctx, identifierNode);
         case 'swap':
         case 'morph':
             return parseSwapCommand(ctx, identifierNode);
@@ -3621,7 +4145,7 @@ function parseFetchCommand(ctx, commandToken) {
     if (!ctx.isAtEnd() && ctx.check('{')) {
         modifiers['with'] = ctx.parsePrimary();
     }
-    for (let i = 0; i < 2 && !ctx.isAtEnd(); i++) {
+    for (let i = 0; i < 3 && !ctx.isAtEnd(); i++) {
         if (ctx.check('as') && !modifiers['as']) {
             ctx.advance();
             if (!ctx.isAtEnd()) {
@@ -3640,491 +4164,335 @@ function parseFetchCommand(ctx, commandToken) {
             }
             continue;
         }
-        break;
-    }
-    const builder = CommandNodeBuilder.from(commandToken).withArgs(url).endingAt(ctx.getPosition());
-    if (Object.keys(modifiers).length > 0) {
-        builder.withModifiers(modifiers);
-    }
-    return builder.build();
-}
-function isFetchNakedNamedArgStart(ctx) {
-    if (ctx.check('{'))
-        return false;
-    if (!ctx.checkIdentifierLike())
-        return false;
-    const next = ctx.peekAt(1);
-    return next !== null && next.value === ':';
-}
-function parseFetchNakedNamedArgs(ctx) {
-    const properties = [];
-    const startPos = ctx.getPosition();
-    do {
-        if (!ctx.checkIdentifierLike())
-            break;
-        const keyToken = ctx.advance();
-        const key = {
-            type: 'identifier',
-            name: keyToken.value,
-            start: keyToken.start,
-            end: keyToken.end,
-            line: keyToken.line,
-            column: keyToken.column,
-        };
-        ctx.consume(':', "Expected ':' after property name in fetch named arguments");
-        const value = ctx.parsePrimary();
-        if (value) {
-            properties.push({ key, value });
-        }
-    } while (ctx.match(',') && !ctx.isAtEnd());
-    const endPos = ctx.getPosition();
-    return {
-        type: 'objectLiteral',
-        properties,
-        start: startPos.start,
-        end: endPos.end,
-        line: startPos.line,
-        column: startPos.column,
-    };
-}
-function findJsEndBoundary(ctx, startPos) {
-    const input = ctx.getInputSlice(startPos);
-    if (!input) {
-        return startPos;
-    }
-    let i = 0;
-    while (i < input.length) {
-        const ch = input[i];
-        if (ch === "'" || ch === '\u2019' || ch === '\u2018') {
-            i++;
-            while (i < input.length && input[i] !== ch) {
-                if (input[i] === '\\')
-                    i++;
-                i++;
-            }
-            i++;
-            continue;
-        }
-        if (ch === '"') {
-            i++;
-            while (i < input.length && input[i] !== '"') {
-                if (input[i] === '\\')
-                    i++;
-                i++;
-            }
-            i++;
-            continue;
-        }
-        if (ch === '`') {
-            i++;
-            while (i < input.length && input[i] !== '`') {
-                if (input[i] === '\\')
-                    i++;
-                i++;
-            }
-            i++;
-            continue;
-        }
-        if (ch === '/' && i + 1 < input.length && input[i + 1] === '/') {
-            i += 2;
-            while (i < input.length && input[i] !== '\n')
-                i++;
-            continue;
-        }
-        if (ch === '/' && i + 1 < input.length && input[i + 1] === '*') {
-            i += 2;
-            while (i < input.length &&
-                !(input[i] === '*' && i + 1 < input.length && input[i + 1] === '/'))
-                i++;
-            i += 2;
-            continue;
-        }
-        if ((ch === 'e' || ch === 'E') &&
-            i + 3 <= input.length &&
-            input.slice(i, i + 3).toLowerCase() === 'end') {
-            const before = i === 0 || !/[a-zA-Z0-9_]/.test(input[i - 1]);
-            const after = i + 3 >= input.length || !/[a-zA-Z0-9_]/.test(input[i + 3]);
-            if (before && after) {
-                return startPos + i;
-            }
-        }
-        i++;
-    }
-    return startPos + input.length;
-}
-function parseJsCommand(ctx, identifierNode) {
-    const parameters = [];
-    if (ctx.match('(')) {
-        while (!ctx.check(')') && !ctx.isAtEnd()) {
-            if (ctx.checkIdentifierLike()) {
-                parameters.push(ctx.advance().value);
-            }
-            ctx.match(',');
-        }
-        ctx.consume(')', 'Expected ) after js parameters');
-    }
-    const jsCodeStart = ctx.peek().start;
-    const jsCodeEnd = findJsEndBoundary(ctx, jsCodeStart);
-    while (!ctx.isAtEnd() && !ctx.check(KEYWORDS.END)) {
-        if (ctx.peek().start >= jsCodeEnd)
-            break;
-        ctx.advance();
-    }
-    ctx.consume(KEYWORDS.END, 'Expected end after js code body');
-    const rawSlice = ctx.getInputSlice(jsCodeStart, jsCodeEnd);
-    const code = rawSlice.trim();
-    const codeNode = {
-        type: 'literal',
-        value: code,
-        start: identifierNode.start,
-        end: ctx.getPosition().end,
-    };
-    const paramsNode = {
-        type: 'arrayLiteral',
-        elements: parameters.map(p => ({
-            type: 'literal',
-            value: p,
-            start: identifierNode.start,
-            end: identifierNode.end,
-        })),
-        start: identifierNode.start,
-        end: ctx.getPosition().end,
-    };
-    return CommandNodeBuilder.fromIdentifier(identifierNode)
-        .withArgs(codeNode, paramsNode)
-        .endingAt(ctx.getPosition())
-        .build();
-}
-function parseTellCommand(ctx, identifierNode) {
-    const target = ctx.parseExpression();
-    if (!target) {
-        throw new Error('tell command requires a target expression');
-    }
-    const commands = [];
-    while (!ctx.isAtEnd()) {
-        if (ctx.checkIsCommand()) {
-            try {
+        if (ctx.check('do') && !modifiers['doNotThrow']) {
+            const n1 = ctx.peekAt(1);
+            const n2 = ctx.peekAt(2);
+            if (n1?.value === 'not' && n2?.value === 'throw') {
+                const doToken = ctx.advance();
                 ctx.advance();
-                const cmd = ctx.parseCommand();
-                if (cmd) {
-                    commands.push(cmd);
-                }
-                else {
-                    break;
-                }
-            }
-            catch {
-                break;
-            }
-            if (ctx.match(KEYWORDS.AND)) {
-                continue;
-            }
-            if (ctx.check(KEYWORDS.THEN) || ctx.check(KEYWORDS.ELSE) || ctx.check(KEYWORDS.END)) {
-                break;
-            }
-            if (ctx.checkIsCommand()) {
-                continue;
-            }
-            break;
-        }
-        else {
-            break;
-        }
-    }
-    if (commands.length === 0) {
-        throw new Error('tell command requires at least one command after the target');
-    }
-    return CommandNodeBuilder.fromIdentifier(identifierNode)
-        .withArgs(target, ...commands)
-        .endingAt(ctx.getPosition())
-        .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 });
+                const throwToken = ctx.advance();
+                modifiers['doNotThrow'] = {
+                    type: 'literal',
+                    value: true,
+                    start: doToken.start,
+                    end: throwToken.end,
+                    line: doToken.line,
+                    column: doToken.column,
+                };
+                continue;
             }
         }
+        break;
     }
-    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,
-                })),
-        },
-    };
+    const builder = CommandNodeBuilder.from(commandToken).withArgs(url).endingAt(ctx.getPosition());
+    if (Object.keys(modifiers).length > 0) {
+        builder.withModifiers(modifiers);
+    }
+    return builder.build();
 }
-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 isFetchNakedNamedArgStart(ctx) {
+    if (ctx.check('{'))
+        return false;
+    if (!ctx.checkIdentifierLike())
+        return false;
+    const next = ctx.peekAt(1);
+    return next !== null && next.value === ':';
 }
-function prefix(bp, handler) {
+function parseFetchNakedNamedArgs(ctx) {
+    const properties = [];
+    const startPos = ctx.getPosition();
+    do {
+        if (!ctx.checkIdentifierLike())
+            break;
+        const keyToken = ctx.advance();
+        const key = {
+            type: 'identifier',
+            name: keyToken.value,
+            start: keyToken.start,
+            end: keyToken.end,
+            line: keyToken.line,
+            column: keyToken.column,
+        };
+        ctx.consume(':', "Expected ':' after property name in fetch named arguments");
+        const value = ctx.parsePrimary();
+        if (value) {
+            properties.push({ key, value });
+        }
+    } while (ctx.match(',') && !ctx.isAtEnd());
+    const endPos = ctx.getPosition();
     return {
-        prefix: {
-            bp,
-            handler: handler ??
-                ((token, ctx) => ({
-                    type: 'unaryExpression',
-                    operator: token.value,
-                    operand: ctx.parseExpr(bp),
-                    start: token.start,
-                })),
-        },
+        type: 'objectLiteral',
+        properties,
+        start: startPos.start,
+        end: endPos.end,
+        line: startPos.line,
+        column: startPos.column,
     };
 }
-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 findJsEndBoundary(ctx, startPos) {
+    const input = ctx.getInputSlice(startPos);
+    if (!input) {
+        return startPos;
+    }
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === "'" || ch === '\u2019' || ch === '\u2018') {
+            i++;
+            while (i < input.length && input[i] !== ch) {
+                if (input[i] === '\\')
+                    i++;
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"') {
+            i++;
+            while (i < input.length && input[i] !== '"') {
+                if (input[i] === '\\')
+                    i++;
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '`') {
+            i++;
+            while (i < input.length && input[i] !== '`') {
+                if (input[i] === '\\')
+                    i++;
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '/' && i + 1 < input.length && input[i + 1] === '/') {
+            i += 2;
+            while (i < input.length && input[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && i + 1 < input.length && input[i + 1] === '*') {
+            i += 2;
+            while (i < input.length &&
+                !(input[i] === '*' && i + 1 < input.length && input[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        if ((ch === 'e' || ch === 'E') &&
+            i + 3 <= input.length &&
+            input.slice(i, i + 3).toLowerCase() === 'end') {
+            const before = i === 0 || !/[a-zA-Z0-9_]/.test(input[i - 1]);
+            const after = i + 3 >= input.length || !/[a-zA-Z0-9_]/.test(input[i + 3]);
+            if (before && after) {
+                return startPos + i;
+            }
+        }
+        i++;
+    }
+    return startPos + input.length;
+}
+function parseJsCommand(ctx, identifierNode) {
+    const parameters = [];
+    if (ctx.match('(')) {
+        while (!ctx.check(')') && !ctx.isAtEnd()) {
+            if (ctx.checkIdentifierLike()) {
+                parameters.push(ctx.advance().value);
+            }
+            ctx.match(',');
+        }
+        ctx.consume(')', 'Expected ) after js parameters');
+    }
+    const jsCodeStart = ctx.peek().start;
+    const jsCodeEnd = findJsEndBoundary(ctx, jsCodeStart);
+    while (!ctx.isAtEnd() && !ctx.check(KEYWORDS.END)) {
+        if (ctx.peek().start >= jsCodeEnd)
+            break;
+        ctx.advance();
+    }
+    ctx.consume(KEYWORDS.END, 'Expected end after js code body');
+    const rawSlice = ctx.getInputSlice(jsCodeStart, jsCodeEnd);
+    const code = rawSlice.trim();
+    const codeNode = {
+        type: 'literal',
+        value: code,
+        start: identifierNode.start,
+        end: ctx.getPosition().end,
+    };
+    const paramsNode = {
+        type: 'arrayLiteral',
+        elements: parameters.map(p => ({
+            type: 'literal',
+            value: p,
+            start: identifierNode.start,
+            end: identifierNode.end,
+        })),
+        start: identifierNode.start,
+        end: ctx.getPosition().end,
+    };
+    return CommandNodeBuilder.fromIdentifier(identifierNode)
+        .withArgs(codeNode, paramsNode)
+        .endingAt(ctx.getPosition())
+        .build();
+}
+function parseTellCommand(ctx, identifierNode) {
+    const target = ctx.parseExpression();
+    if (!target) {
+        throw new Error('tell command requires a target expression');
+    }
+    const commands = [];
+    while (!ctx.isAtEnd()) {
+        if (ctx.checkIsCommand()) {
+            try {
+                ctx.advance();
+                const cmd = ctx.parseCommand();
+                if (cmd) {
+                    commands.push(cmd);
+                }
+                else {
+                    break;
+                }
+            }
+            catch {
+                break;
+            }
+            if (ctx.match(KEYWORDS.AND)) {
+                continue;
+            }
+            if (ctx.check(KEYWORDS.THEN) || ctx.check(KEYWORDS.ELSE) || ctx.check(KEYWORDS.END)) {
+                break;
+            }
+            if (ctx.checkIsCommand()) {
+                continue;
+            }
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    if (commands.length === 0) {
+        throw new Error('tell command requires at least one command after the target');
+    }
+    return CommandNodeBuilder.fromIdentifier(identifierNode)
+        .withArgs(target, ...commands)
+        .endingAt(ctx.getPosition())
+        .build();
+}
+function parsePickCommand(ctx, identifierNode) {
+    const builder = CommandNodeBuilder.fromIdentifier(identifierNode);
+    consumeOptionalKeyword(ctx, KEYWORDS.THE);
+    const variantToken = ctx.peek();
+    const variantName = variantToken.value;
+    const makeStringLiteral = (value) => ({
+        type: 'literal',
+        value,
+        start: identifierNode.start,
+        end: identifierNode.end,
+    });
+    const consumeSource = () => {
+        if (!ctx.match('of', 'from')) {
+            throw new Error(`pick: expected 'of' or 'from' before source expression`);
+        }
+        return ctx.parseExpression();
+    };
+    if (variantName === 'first') {
+        ctx.advance();
+        const count = ctx.parsePrimary();
+        const source = consumeSource();
+        return builder
+            .withArgs(source)
+            .withModifier('variant', makeStringLiteral('first'))
+            .withModifier('count', count)
+            .endingAt(ctx.getPosition())
+            .build();
+    }
+    if (variantName === 'last') {
+        ctx.advance();
+        const count = ctx.parsePrimary();
+        const source = consumeSource();
+        return builder
+            .withArgs(source)
+            .withModifier('variant', makeStringLiteral('last'))
+            .withModifier('count', count)
+            .endingAt(ctx.getPosition())
+            .build();
+    }
+    if (variantName === 'random') {
+        ctx.advance();
+        let countNode;
+        if (!ctx.check('of') && !ctx.check('from')) {
+            countNode = ctx.parsePrimary();
+        }
+        const source = consumeSource();
+        const b = builder.withArgs(source).withModifier('variant', makeStringLiteral('random'));
+        if (countNode)
+            b.withModifier('count', countNode);
+        return b.endingAt(ctx.getPosition()).build();
+    }
+    if (variantName === 'item' ||
+        variantName === 'items' ||
+        variantName === 'character' ||
+        variantName === 'characters') {
+        ctx.advance();
+        ctx.match('at', 'from');
+        let rangeStart;
+        if (ctx.match('start')) {
+            rangeStart = makeStringLiteral('start');
+        }
+        else {
+            rangeStart = ctx.parsePrimary();
+        }
+        let rangeEnd;
+        let endIsEndKeyword = false;
+        if (ctx.match('to') || ctx.match('..')) {
+            if (ctx.match('end')) {
+                endIsEndKeyword = true;
+            }
+            else {
+                rangeEnd = ctx.parsePrimary();
+            }
+        }
+        let mode = 'default';
+        if (ctx.match('inclusive'))
+            mode = 'inclusive';
+        else if (ctx.match('exclusive'))
+            mode = 'exclusive';
+        const source = consumeSource();
+        const b = builder
+            .withArgs(source)
+            .withModifier('variant', makeStringLiteral('range'))
+            .withModifier('rangeStart', rangeStart)
+            .withModifier('rangeMode', makeStringLiteral(mode));
+        if (endIsEndKeyword) {
+            b.withModifier('rangeEnd', makeStringLiteral('end'));
+        }
+        else if (rangeEnd) {
+            b.withModifier('rangeEnd', rangeEnd);
+        }
+        return b.endingAt(ctx.getPosition()).build();
+    }
+    if (variantName === 'match' || variantName === 'matches') {
+        ctx.advance();
+        ctx.match('of');
+        const regex = ctx.parsePrimary();
+        let flags;
+        if (ctx.matchOperator('|')) {
+            flags = ctx.advance().value;
+        }
+        const source = consumeSource();
+        const b = builder
+            .withArgs(source)
+            .withModifier('variant', makeStringLiteral(variantName === 'match' ? 'match' : 'matches'))
+            .withModifier('regex', regex);
+        if (flags)
+            b.withModifier('flags', makeStringLiteral(flags));
+        return b.endingAt(ctx.getPosition()).build();
+    }
+    return parseRegularCommand(ctx, identifierNode);
+}
 
 function parseTimeToMs(timeStr) {
     if (timeStr.endsWith('ms'))
@@ -4216,7 +4584,13 @@ class Parser {
                     warnings: this.warnings,
                 };
             }
-            if (this.check('init') || this.check('on') || this.check('def') || this.checkComment()) {
+            const topToken = this.peek();
+            const topPluginFeature = topToken && getRegisteredFeature(topToken.value) ? topToken.value : null;
+            if (this.check('init') ||
+                this.check('on') ||
+                this.check('def') ||
+                this.checkComment() ||
+                topPluginFeature !== null) {
                 const statements = [];
                 while (!this.isAtEnd()) {
                     if (this.checkComment()) {
@@ -4245,6 +4619,16 @@ class Parser {
                         }
                     }
                     else {
+                        const tok = this.peek();
+                        const pluginParse = tok ? getRegisteredFeature(tok.value) : undefined;
+                        if (pluginParse) {
+                            const featureToken = this.advance();
+                            const featureNode = pluginParse(this.getContext(), featureToken);
+                            if (featureNode) {
+                                statements.push(featureNode);
+                            }
+                            continue;
+                        }
                         break;
                     }
                 }
@@ -4364,7 +4748,14 @@ class Parser {
                 };
             }
             if (!this.isAtEnd()) {
-                this.addError(`Unexpected token: ${this.peek().value}`);
+                const next = this.peek();
+                const valueLikeKinds = ['number', 'string', 'identifier'];
+                if (ast && valueLikeKinds.includes(next.kind)) {
+                    this.addError(`Unexpected token: ${next.value} (missing operator between values? expected one of +, -, *, /, etc.)`);
+                }
+                else {
+                    this.addError(`Unexpected token: ${next.value}`);
+                }
                 return {
                     success: false,
                     node: ast || this.createErrorNode(),
@@ -4442,7 +4833,8 @@ class Parser {
                         try {
                             this.parseExpressionPratt(0);
                         }
-                        catch {
+                        catch (recoveryErr) {
+                            debug.parse('arrow body discarded after error:', recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr));
                         }
                     }
                     return this.createErrorNode();
@@ -4501,143 +4893,8 @@ class Parser {
             atEnd: () => self.current >= self.tokens.length,
         };
     }
-    parseAssignment() {
-        let expr = this.parseLogicalOr();
-        if (this.match('=')) {
-            if (this.check('>')) {
-                this.advance();
-                this.addError('Arrow functions (=>) are not supported in hyperscript. ' +
-                    'Use "js ... end" blocks for JavaScript callbacks.');
-                if (!this.isAtEnd()) {
-                    try {
-                        this.parseExpression();
-                    }
-                    catch {
-                    }
-                }
-                return this.createErrorNode();
-            }
-            const operator = this.previous().value;
-            const right = this.parseAssignment();
-            expr = this.createBinaryExpression(operator, expr, right);
-        }
-        return expr;
-    }
-    parseLogicalOr() {
-        let expr = this.parseLogicalAnd();
-        while (this.match('or')) {
-            const operator = this.previous().value;
-            const right = this.parseLogicalAnd();
-            expr = this.createBinaryExpression(operator, expr, right);
-        }
-        return expr;
-    }
     parseLogicalAnd() {
-        let expr = this.parseEquality();
-        while (this.match('and')) {
-            const operator = this.previous().value;
-            const right = this.parseEquality();
-            expr = this.createBinaryExpression(operator, expr, right);
-        }
-        return expr;
-    }
-    parseEquality() {
-        let expr = this.parseComparison();
-        while (this.matchComparisonOperator() ||
-            this.match('is', 'match', 'matches', 'contains', 'include', 'includes', 'in', 'of', 'as', 'really')) {
-            const operator = this.previous().value;
-            if (Parser.POSTFIX_UNARY_OPERATORS.has(operator)) {
-                expr = this.createUnaryExpression(operator, expr, false);
-                continue;
-            }
-            const right = this.parseComparison();
-            expr = this.createBinaryExpression(operator, expr, right);
-        }
-        return expr;
-    }
-    parseComparison() {
-        let expr = this.parseAddition();
-        while (this.matchComparisonOperator()) {
-            const operator = this.previous().value;
-            if (Parser.POSTFIX_UNARY_OPERATORS.has(operator)) {
-                expr = this.createUnaryExpression(operator, expr, false);
-                continue;
-            }
-            const right = this.parseAddition();
-            expr = this.createBinaryExpression(operator, expr, right);
-        }
-        return expr;
-    }
-    parseAddition() {
-        let expr = this.parseMultiplication();
-        while (this.match('+', '-') || this.matchOperator('+') || this.matchOperator('-')) {
-            const operator = this.previous().value;
-            if (this.check('+') || this.check('-')) {
-                this.addError(`Invalid operator combination: ${operator}${this.peek().value}`);
-                return expr;
-            }
-            if (this.isAtEnd()) {
-                this.addError(`Expected expression after '${operator}' operator`);
-                return expr;
-            }
-            const right = this.parseMultiplication();
-            expr = this.createBinaryExpression(operator, expr, right);
-        }
-        return expr;
-    }
-    parseMultiplication() {
-        let expr = this.parseUnary();
-        while (this.match('*', '/', '%', 'mod')) {
-            const operator = this.previous().value;
-            if (this.check('*') ||
-                this.check('/') ||
-                this.check('%') ||
-                this.check('+') ||
-                this.check('-')) {
-                const nextOp = this.peek().value;
-                if (operator === '*' && nextOp === '*') {
-                    this.addError(`Unexpected token: ${nextOp}`);
-                }
-                else {
-                    this.addError(`Invalid operator combination: ${operator}${nextOp}`);
-                }
-                return expr;
-            }
-            if (this.isAtEnd()) {
-                this.addError(`Expected expression after '${operator}' operator`);
-                return expr;
-            }
-            const right = this.parseUnary();
-            expr = this.createBinaryExpression(operator, expr, right);
-        }
-        return expr;
-    }
-    parseUnary() {
-        if (this.match('not', 'no', 'exists', 'some', '-', '+')) {
-            const operator = this.previous().value;
-            if (this.isAtEnd()) {
-                this.addError(`Expected expression after '${operator}' operator`);
-                return this.createErrorNode();
-            }
-            const expr = this.parseUnary();
-            return this.createUnaryExpression(operator, expr, true);
-        }
-        if (this.check('does') &&
-            this.current + 1 < this.tokens.length &&
-            this.tokens[this.current + 1].value === 'not' &&
-            this.current + 2 < this.tokens.length &&
-            this.tokens[this.current + 2].value === 'exist') {
-            this.advance();
-            this.advance();
-            this.advance();
-            if (this.isAtEnd()) {
-                this.addError(`Expected expression after 'does not exist' operator`);
-                return this.createErrorNode();
-            }
-            const expr = this.parseUnary();
-            return this.createUnaryExpression('does not exist', expr, true);
-        }
-        return this.parseImplicitBinary();
+        return this.parseExpressionPratt(11);
     }
     parseImplicitBinary() {
         let expr = this.parseCall();
@@ -4785,10 +5042,11 @@ class Parser {
     parseTriggerCommand(identifierNode) {
         return parseTriggerCommand(this.getContext(), identifierNode);
     }
-    parseCommandListUntilEnd() {
+    parseCommandListUntilTerminator(extraStops) {
         const commands = [];
-        debug.parse('🔄 parseCommandListUntilEnd: Starting to parse command list');
-        while (!this.isAtEnd() && !this.check('end')) {
+        const isStop = () => this.check('end') || extraStops.some(s => this.check(s));
+        debug.parse('🔄 parseCommandListUntilTerminator: Starting (extraStops:', extraStops.join(','), ')');
+        while (!this.isAtEnd() && !isStop()) {
             debug.parse('📍 Loop iteration, current token:', this.peek().value, 'kind:', this.peek().kind);
             let parsedCommand = false;
             const isCommandToken = this.checkIsCommand();
@@ -4800,7 +5058,7 @@ class Parser {
                 try {
                     const cmd = this.parseCommand();
                     if (this.error && this.error !== savedError) {
-                        debug.parse('⚠️  parseCommandListUntilEnd: Command parsing added error, restoring error state. Error was:', this.error.message);
+                        debug.parse('⚠️  parseCommandListUntilTerminator: Command parsing added error, restoring. Error was:', this.error.message);
                         this.error = savedError;
                     }
                     if (cmd) {
@@ -4810,7 +5068,7 @@ class Parser {
                     }
                 }
                 catch (error) {
-                    debug.parse('⚠️  parseCommandListUntilEnd: Command parsing threw exception, restoring error state:', error instanceof Error ? error.message : String(error));
+                    debug.parse('⚠️  parseCommandListUntilTerminator: Command parsing threw, restoring:', error instanceof Error ? error.message : String(error));
                     this.error = savedError;
                 }
             }
@@ -4823,7 +5081,7 @@ class Parser {
             }
             debug.parse('📍 After parsing command, current token:', this.peek().value);
             while (!this.isAtEnd() &&
-                !this.check('end') &&
+                !isStop() &&
                 !this.checkIsCommand() &&
                 !this.isCommand(this.peek().value) &&
                 !this.check('then') &&
@@ -4845,6 +5103,21 @@ class Parser {
                 break;
             }
         }
+        let terminator = 'end';
+        for (const s of extraStops) {
+            if (this.check(s)) {
+                terminator = s;
+                break;
+            }
+        }
+        if (!this.check('end') && !extraStops.some(s => this.check(s))) {
+            terminator = '';
+        }
+        debug.parse('✅ parseCommandListUntilTerminator: parsed', commands.length, 'commands (terminator:', terminator, ')');
+        return { commands, terminator };
+    }
+    parseCommandListUntilEnd() {
+        const { commands } = this.parseCommandListUntilTerminator([]);
         debug.parse('🔍 After loop, checking for "end". Current token:', this.peek().value);
         if (this.check('end')) {
             debug.parse('✅ Found "end", consuming it');
@@ -4854,9 +5127,35 @@ class Parser {
             debug.parse('❌ ERROR: Expected "end" but got:', this.peek().value, 'at position:', this.peek().start);
             throw new Error('Expected "end" to close repeat block');
         }
-        debug.parse('✅ parseCommandListUntilEnd: Successfully parsed', commands.length, 'commands');
         return commands;
     }
+    parseCommandListUntilEndOrElse() {
+        const { commands, terminator } = this.parseCommandListUntilTerminator(['else']);
+        const hasElse = terminator === 'else';
+        if (!hasElse) {
+            if (this.check('end')) {
+                this.advance();
+            }
+            else {
+                throw new Error('Expected "end" to close repeat block');
+            }
+        }
+        return { commands, hasElse };
+    }
+    parseRepeatBody() {
+        const { commands, terminator } = this.parseCommandListUntilTerminator([
+            'else',
+            'until',
+            'while',
+        ]);
+        if (terminator === 'end') {
+            this.advance();
+        }
+        else if (terminator === '') {
+            throw new Error('Expected "end", "else", "until", or "while" to close repeat block');
+        }
+        return { commands, terminator };
+    }
     parseRepeatCommand(commandToken) {
         return parseRepeatCommand(this.getContext(), commandToken);
     }
@@ -4894,9 +5193,15 @@ class Parser {
                 expr = this.finishCall(expr);
             }
             else if (this.match('.')) {
-                const name = this.consumeIdentifier("Expected property name after '.' - malformed member access");
+                const name = this.consumeIdentifierLike("Expected property name after '.' - malformed member access");
                 expr = this.createMemberExpression(expr, this.createIdentifier(name.value), false);
             }
+            else if (this.match('?.')) {
+                const name = this.consumeIdentifierLike("Expected property name after '?.' - malformed optional access");
+                const memberNode = this.createMemberExpression(expr, this.createIdentifier(name.value), false);
+                memberNode.optional = true;
+                expr = memberNode;
+            }
             else if (this.match('[')) {
                 const index = this.parseExpression();
                 this.consume(']', "Expected ']' after array index");
@@ -4996,7 +5301,9 @@ class Parser {
         if (this.matchQueryReference()) {
             const queryValue = this.previous().value;
             const selector = queryValue.slice(1, -2).trim();
-            return this.createSelector(selector);
+            const node = this.createSelector(selector);
+            node.fromQuery = true;
+            return node;
         }
         if (this.matchSelector()) {
             return this.createSelector(this.previous().value);
@@ -5107,15 +5414,23 @@ class Parser {
                     }
                     this.current = hashPos;
                 }
+                if (!this.isAtEnd() &&
+                    !this.checkBasicOperator() &&
+                    !this.check('then') &&
+                    !this.check('else') &&
+                    !this.check('end')) {
+                    return this.parseNavigationFunction(token.value);
+                }
                 return this.createIdentifier(token.value);
             }
-            if (token.value === 'my' && !this.check('.')) {
+            const nextIsDotChain = this.check('.') || this.check('?.');
+            if (token.value === 'my' && !nextIsDotChain) {
                 return this.parseContextPropertyAccess('me');
             }
-            if (token.value === 'its' && !this.check('.')) {
+            if (token.value === 'its' && !nextIsDotChain) {
                 return this.parseContextPropertyAccess('it');
             }
-            if (token.value === 'your' && !this.check('.')) {
+            if (token.value === 'your' && !nextIsDotChain) {
                 return this.parseContextPropertyAccess('you');
             }
             if (token.value === 'the') {
@@ -5329,18 +5644,11 @@ class Parser {
         this.advance();
         const args = [];
         if (!this.check(')')) {
-            let depth = 1;
-            while (depth > 0 && !this.isAtEnd()) {
-                const token = this.advance();
-                if (token.value === '(')
-                    depth++;
-                if (token.value === ')')
-                    depth--;
-            }
-        }
-        else {
-            this.advance();
+            do {
+                args.push(this.parseExpression());
+            } while (this.match(','));
         }
+        this.consume(')', "Expected ')' after constructor arguments");
         return {
             type: 'callExpression',
             callee: {
@@ -5599,6 +5907,16 @@ class Parser {
     parseEventHandler() {
         debug.parse(`🔧 parseEventHandler: ENTRY - parsing event handler`);
         const eventNames = [];
+        let firstOnceAlias = false;
+        if (this.check('first') && !this.checkIsCommand() && this.current + 1 < this.tokens.length) {
+            const peek2 = this.tokens[this.current + 1];
+            const peek2Value = peek2?.value?.toLowerCase();
+            if (peek2Value && peek2Value !== 'of' && peek2Value !== 'in' && peek2Value !== 'from') {
+                this.advance();
+                firstOnceAlias = true;
+                debug.parse(`🔧 parseEventHandler: Parsed 'first' as .once alias`);
+            }
+        }
         const event = this.parseEventNameWithNamespace("Expected event name after 'on'");
         eventNames.push(event);
         debug.parse(`🔧 parseEventHandler: Parsed first event name: ${event}`);
@@ -5697,6 +6015,9 @@ class Parser {
                 this.addError(`Expected 'at' after '${modName}'`);
             }
         }
+        if (firstOnceAlias) {
+            modifiers.once = true;
+        }
         if (Object.keys(modifiers).length > 0) {
             debug.parse(`🔧 parseEventHandler: Parsed modifiers:`, modifiers);
         }
@@ -6195,7 +6516,8 @@ class Parser {
                 column: commandToken.column,
             };
             const result = this.parseCompoundCommand(identifierNode);
-            return result || this.createErrorNode();
+            return (result ||
+                createPartialCommandNode(lowerName, this.getPosition()));
         }
         const args = [];
         if ((commandName === 'increment' || commandName === 'decrement') && !this.isAtEnd()) {
@@ -6705,6 +7027,34 @@ class Parser {
                 column: startColumn,
             };
         }
+        const ATTR_OPS = new Set(['=', '~=', '|=', '^=', '$=', '*=']);
+        const lookhead = this.tokens[this.current];
+        const lookhead2 = this.tokens[this.current + 1];
+        const isAttrSelector = lookhead?.kind === 'identifier' &&
+            (lookhead2?.value === ']' ||
+                (lookhead2 &&
+                    ATTR_OPS.has(lookhead2.value) &&
+                    this.tokens[this.current + 2]?.kind === 'string'));
+        if (isAttrSelector) {
+            const attrName = this.advance().value;
+            let css = '[' + attrName;
+            if (this.check(']')) {
+                this.advance();
+                css += ']';
+            }
+            else {
+                const op = this.advance().value;
+                const stringTok = this.advance();
+                const raw = stringTok.value;
+                const unquoted = (raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))
+                    ? raw.slice(1, -1)
+                    : raw;
+                css += op + '"' + unquoted + '"';
+                this.consume(']', "Expected ']' after attribute selector");
+                css += ']';
+            }
+            return this.createSelector(css);
+        }
         const elements = [];
         if (!this.check(']')) {
             do {
@@ -6754,41 +7104,15 @@ class Parser {
             matchOperator: this.matchOperator.bind(this),
             isAtEnd: this.isAtEnd.bind(this),
             createIdentifier: this.createIdentifier.bind(this),
-            createLiteral: this.createLiteral.bind(this),
-            createSelector: this.createSelector.bind(this),
-            createBinaryExpression: this.createBinaryExpression.bind(this),
-            createUnaryExpression: this.createUnaryExpression.bind(this),
-            createMemberExpression: this.createMemberExpression.bind(this),
-            createPossessiveExpression: this.createPossessiveExpression.bind(this),
-            createCallExpression: this.createCallExpression.bind(this),
-            createErrorNode: this.createErrorNode.bind(this),
-            createProgramNode: this.createProgramNode.bind(this),
-            createCommandFromIdentifier: this.createCommandFromIdentifier.bind(this),
             parseExpression: this.parseExpression.bind(this),
             parsePrimary: this.parsePrimary.bind(this),
-            parseCall: this.parseCall.bind(this),
-            parseAssignment: this.parseAssignment.bind(this),
-            parseLogicalOr: this.parseLogicalOr.bind(this),
             parseLogicalAnd: this.parseLogicalAnd.bind(this),
-            parseEquality: this.parseEquality.bind(this),
-            parseComparison: this.parseComparison.bind(this),
-            parseAddition: this.parseAddition.bind(this),
-            parseMultiplication: this.parseMultiplication.bind(this),
-            parseImplicitBinary: this.parseImplicitBinary.bind(this),
-            parseConditional: this.parseConditional.bind(this),
-            parseConditionalBranch: this.parseConditionalBranch.bind(this),
-            parseEventHandler: this.parseEventHandler.bind(this),
-            parseBehaviorDefinition: this.parseBehaviorDefinition.bind(this),
-            parseNavigationFunction: this.parseNavigationFunction.bind(this),
-            parseMyPropertyAccess: this.parseMyPropertyAccess.bind(this),
-            parseDollarExpression: this.parseDollarExpression.bind(this),
-            parseHyperscriptSelector: this.parseHyperscriptSelector.bind(this),
-            parseAttributeOrArrayLiteral: this.parseAttributeOrArrayLiteral.bind(this),
-            parseObjectLiteral: this.parseObjectLiteral.bind(this),
             parseCSSObjectLiteral: this.parseCSSObjectLiteral.bind(this),
             parseCommand: this.parseCommand.bind(this),
             parseCommandSequence: this.parseCommandSequence.bind(this),
             parseCommandListUntilEnd: this.parseCommandListUntilEnd.bind(this),
+            parseCommandListUntilEndOrElse: this.parseCommandListUntilEndOrElse.bind(this),
+            parseRepeatBody: this.parseRepeatBody.bind(this),
             getPosition: this.getPosition.bind(this),
             addError: this.addError.bind(this),
             addWarning: this.addWarning.bind(this),
@@ -6831,6 +7155,7 @@ Parser.POSTFIX_UNARY_OPERATORS = new Set([
     'does not exist',
     'is empty',
     'is not empty',
+    'ignoring case',
 ]);
 Parser.PRATT_TABLE = PARSER_TABLE;
 Parser.PSEUDO_COMMAND_PREPOSITIONS = ['from', 'on', 'with', 'into', 'at', 'to'];