@hyperfixi/core 3.1.1 → 3.3.0

package/dist/parser/full-parser.mjs

@@ -1691,6 +1691,39 @@ function makeTypeCheckHandler(negated) {
         };
     };
 }
+const OF_OPERAND_BP = 70;
+function parseOfOperand(ctx, minBp = OF_OPERAND_BP) {
+    let right = ctx.parseExpr(minBp);
+    if (ctx.peek()?.value === 'in') {
+        const inToken = ctx.advance();
+        const scope = ctx.parseExpr(minBp);
+        right = {
+            type: 'binaryExpression',
+            operator: 'in',
+            left: right,
+            right: scope,
+            start: right.start,
+            end: scope.end ?? inToken.end,
+            line: right.line ?? inToken.line,
+            column: right.column ?? inToken.column,
+        };
+    }
+    return right;
+}
+const THE_OF_TARGET_BP = OF_OPERAND_BP + 1;
+function ofHandler(left, token, ctx) {
+    const right = parseOfOperand(ctx);
+    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,
+    };
+}
 const PARSER_COMPARISON_FRAGMENT = new Map([
     ['===', leftAssoc(30)],
     ['!==', leftAssoc(30)],
@@ -1735,7 +1768,7 @@ const PARSER_COMPARISON_FRAGMENT = new Map([
     ['is greater than or equal to', leftAssoc(30)],
     ['is less than or equal to', leftAssoc(30)],
     ['in', leftAssoc(30)],
-    ['of', rightAssoc(30)],
+    ['of', { infix: { bp: [90, OF_OPERAND_BP], handler: ofHandler } }],
     ['really', leftAssoc(30)],
     [
         'exists',
@@ -2232,6 +2265,48 @@ function parseMaybeNamedArgument(ctx) {
     const value = ctx.parseExpression();
     return name !== undefined ? { name, value } : { value };
 }
+function isNakedNamedArgStart(ctx) {
+    if (ctx.check('{'))
+        return false;
+    if (!ctx.checkIdentifierLike())
+        return false;
+    const next = ctx.peekAt(1);
+    return next !== null && next.value === ':';
+}
+function parseNakedNamedArgs(ctx, parseValue, command) {
+    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 ${command} named arguments`);
+        const value = parseValue();
+        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 isGluedBeepBang(beep, bang) {
+    return beep?.value === 'beep' && bang?.value === '!' && bang.start === beep.end;
+}
 
 class CommandNodeBuilder {
     constructor(name) {
@@ -2433,6 +2508,8 @@ function parseTriggerCommand(ctx, identifierNode) {
     const modifiers = {};
     while (!isCommandBoundary(ctx)) {
         if (ctx.check(KEYWORDS.ON) || ctx.check(KEYWORDS.TO)) {
+            if (modifiers['on'])
+                break;
             ctx.advance();
             const target = parseOneArgument(ctx, [KEYWORDS.WITH]);
             if (target)
@@ -2573,6 +2650,9 @@ function parseRepeatCommand(ctx, commandToken) {
         ctx.advance();
         loopType = KEYWORDS.FOREVER;
     }
+    else if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
+        loopType = KEYWORDS.FOREVER;
+    }
     else {
         times = ctx.parseExpression();
         if (ctx.check(KEYWORDS.TIMES)) {
@@ -2615,10 +2695,12 @@ function parseRepeatCommand(ctx, commandToken) {
             loopType = result.terminator;
             ctx.advance();
             condition = ctx.parseExpression();
-            if (!ctx.check('end')) {
+            if (ctx.check('end')) {
+                ctx.advance();
+            }
+            else if (!ctx.atEndOfInput()) {
                 throw new Error('Expected "end" to close repeat block');
             }
-            ctx.advance();
         }
     }
     else {
@@ -2864,7 +2946,7 @@ function parseIfCommand(ctx, commandToken) {
                 }));
             }
         }
-        if (!consumedElseIf && !ctx.isAtEnd()) {
+        if (!consumedElseIf && !ctx.atEndOfInput()) {
             ctx.consume(KEYWORDS.END, "Expected 'end' after if block");
         }
     }
@@ -2889,7 +2971,6 @@ function parseIfCommand(ctx, commandToken) {
         .build();
 }
 function parseForCommand(ctx, commandToken) {
-    const args = [];
     let variable = null;
     let collection = null;
     if (ctx.check(KEYWORDS.EACH)) {
@@ -2932,31 +3013,22 @@ function parseForCommand(ctx, commandToken) {
         }
     }
     const commands = ctx.parseCommandListUntilEnd('for');
-    args.push({
-        type: 'identifier',
-        name: 'for',
-        start: commandToken.start,
-        end: commandToken.end,
-        line: commandToken.line,
-        column: commandToken.column,
-    });
-    const forPos = {
+    const pos = {
         start: commandToken.start,
         end: commandToken.end,
         line: commandToken.line,
         column: commandToken.column,
     };
-    args.push(createStringLiteral(variable, forPos));
-    args.push(collection);
-    if (indexVariable) {
-        args.push(createStringLiteral(indexVariable, forPos));
-    }
-    args.push(createBlock(commands, { ...forPos, end: forPos.end || 0 }));
-    return CommandNodeBuilder.from({
-        ...commandToken,
-        value: 'repeat',
-    })
-        .withArgs(...args)
+    const modifiers = {
+        loopType: toLegacyExpression(createStringLiteral(KEYWORDS.FOR, pos)),
+        for: toLegacyExpression(createStringLiteral(variable, pos)),
+        in: collection,
+    };
+    if (indexVariable)
+        modifiers['index'] = toLegacyExpression(createStringLiteral(indexVariable, pos));
+    return CommandNodeBuilder.from({ ...commandToken, value: 'repeat' })
+        .withArgs(createBlock(commands, { ...pos, end: pos.end || 0 }))
+        .withModifiers(modifiers)
         .endingAt(ctx.getPosition())
         .build();
 }
@@ -3012,86 +3084,159 @@ function parseMeasureCommand(ctx, identifierNode) {
     }
     return builder.build();
 }
-const CONTEXT_POSSESSIVES = new Set(['my', 'its', 'your']);
+const CONTEXT_REFS = new Set(['me', 'it', 'you', 'result']);
 function parseTransitionCommand(ctx, commandToken) {
-    const args = [];
-    const modifiers = {};
-    let property = null;
-    let target = null;
-    const leadToken = ctx.peek();
-    const startsTarget = ctx.checkAnySelector() ||
-        ctx.checkContextVar() ||
-        ctx.check('<') ||
-        (isIdentifierLike(leadToken) && CONTEXT_POSSESSIVES.has(leadToken.value));
-    if (startsTarget) {
-        const parsed = ctx.parsePrimary();
-        if ((parsed.type === 'possessiveExpression' ||
-            (parsed.type === 'memberExpression' && !parsed.computed)) &&
-            parsed.object &&
-            parsed.property?.name) {
-            target = parsed.object;
-            property = {
-                type: 'string',
-                value: parsed.property.name,
-                start: leadToken.start || 0,
-                end: ctx.getPosition().end,
-                line: leadToken.line,
-                column: leadToken.column,
-            };
+    const pairs = [];
+    do {
+        pairs.push(parseTransitionPair(ctx));
+    } while (startsAnotherPair(ctx));
+    const [first, ...rest] = pairs;
+    const args = first.owner ? [first.owner, first.property] : [first.property];
+    const modifiers = { to: first.to };
+    if (first.from)
+        modifiers['from'] = first.from;
+    if (rest.length > 0)
+        modifiers['pairs'] = pairsNode(rest);
+    for (let i = 0; i < 3 && !ctx.isAtEnd(); i++) {
+        if (ctx.check('over') && !modifiers['over']) {
+            ctx.advance();
+            modifiers['over'] = ctx.parseExpression();
         }
-        else {
-            target = parsed;
-            if (ctx.check("'s"))
-                ctx.advance();
+        else if (ctx.check('using') && !modifiers['using']) {
+            ctx.advance();
+            modifiers['using'] = ctx.parseExpression();
         }
-    }
-    const firstToken = ctx.peek();
-    if (!property && (isIdentifierLike(firstToken) || firstToken.value === '*')) {
-        let propertyValue = '';
-        if (ctx.check('*')) {
-            propertyValue = '*';
+        else if (ctx.check(KEYWORDS.WITH) && !modifiers['with']) {
             ctx.advance();
+            modifiers['with'] = ctx.parsePrimary();
         }
-        const hyphenatedName = parseHyphenatedName(ctx);
-        if (hyphenatedName) {
-            propertyValue += hyphenatedName;
-            property = {
-                type: 'string',
-                value: propertyValue,
-                start: firstToken.start || 0,
-                end: ctx.getPosition().end,
-                line: firstToken.line,
-                column: firstToken.column,
-            };
+        else {
+            break;
         }
     }
-    if (!property) {
-        throw new Error('Transition command requires a CSS property');
+    return CommandNodeBuilder.from(commandToken)
+        .withArgs(...args)
+        .withModifiers(modifiers)
+        .endingAt(ctx.getPosition())
+        .build();
+}
+function parseTransitionPair(ctx) {
+    const { owner, property } = parseTransitionProperty(ctx);
+    let from = null;
+    if (ctx.check('from')) {
+        ctx.advance();
+        from = ctx.parseExpression();
     }
-    if (target)
-        args.push(target);
-    args.push(property);
     if (!ctx.check(KEYWORDS.TO)) {
         throw new Error('Expected "to" keyword after property in transition command');
     }
     ctx.advance();
-    const value = ctx.parseExpression();
-    modifiers['to'] = value;
-    if (ctx.check('over')) {
-        ctx.advance();
-        const duration = ctx.parseExpression();
-        modifiers['over'] = duration;
+    const to = ctx.parseExpression();
+    return { owner, property, from, to };
+}
+function parseTransitionProperty(ctx) {
+    const lead = ctx.peek();
+    if (!lead || isKeyword(lead, [KEYWORDS.TO, 'from'])) {
+        throw new Error('Transition command requires a CSS property');
     }
-    if (ctx.check(KEYWORDS.WITH)) {
+    const expr = ctx.parseExpression();
+    const split = splitStyleExpression(expr);
+    if (split)
+        return { owner: split.owner, property: propertyNode(split.name, lead, ctx) };
+    let name = '';
+    if (ctx.check('*')) {
+        name = '*';
         ctx.advance();
-        const timingFunction = ctx.parsePrimary();
-        modifiers['with'] = timingFunction;
     }
-    return CommandNodeBuilder.from(commandToken)
-        .withArgs(...args)
-        .withModifiers(modifiers)
-        .endingAt(ctx.getPosition())
-        .build();
+    const hyphenated = parseHyphenatedName(ctx);
+    if (!hyphenated)
+        throw new Error('Transition command requires a CSS property');
+    return { owner: expr, property: propertyNode(name + hyphenated, lead, ctx) };
+}
+function splitStyleExpression(node) {
+    const n = node;
+    switch (n.type) {
+        case 'selector':
+            return typeof n.value === 'string' && n.value.startsWith('*')
+                ? { owner: null, name: n.value }
+                : null;
+        case 'identifier':
+            return typeof n.name === 'string' && !CONTEXT_REFS.has(n.name)
+                ? { owner: null, name: n.name }
+                : null;
+        case 'possessiveExpression':
+        case 'memberExpression':
+            return !n.computed && n.object && typeof n.property?.name === 'string'
+                ? { owner: n.object, name: n.property.name }
+                : null;
+        case 'binaryExpression': {
+            if (n.operator !== 'of' || !n.left || !n.right)
+                return null;
+            const inner = splitStyleExpression(n.left);
+            return inner && !inner.owner ? { owner: n.right, name: inner.name } : null;
+        }
+        case 'propertyOfExpression':
+            return n.target && typeof n.property?.name === 'string'
+                ? { owner: n.target, name: n.property.name }
+                : null;
+        default:
+            return null;
+    }
+}
+function propertyNode(name, lead, ctx) {
+    return {
+        type: 'string',
+        value: name,
+        start: lead.start || 0,
+        end: ctx.getPosition().end,
+        line: lead.line,
+        column: lead.column,
+    };
+}
+function startsAnotherPair(ctx) {
+    if (ctx.isAtEnd() || isComment(ctx.peek()))
+        return false;
+    if (isKeyword(ctx.peek(), ['over', 'using', KEYWORDS.WITH]))
+        return false;
+    return !isCommandBoundary(ctx, ['catch', 'finally', 'on']);
+}
+function pairsNode(pairs) {
+    const field = (name, value) => ({
+        key: {
+            type: 'identifier',
+            name,
+            start: value.start,
+            end: value.end,
+            line: value.line,
+            column: value.column,
+        },
+        value,
+    });
+    const elements = pairs.map(pair => {
+        const properties = [field('property', pair.property), field('to', pair.to)];
+        if (pair.owner)
+            properties.push(field('owner', pair.owner));
+        if (pair.from)
+            properties.push(field('from', pair.from));
+        return {
+            type: 'objectLiteral',
+            properties,
+            start: (pair.owner ?? pair.property).start,
+            end: pair.to.end,
+            line: (pair.owner ?? pair.property).line,
+            column: (pair.owner ?? pair.property).column,
+        };
+    });
+    const firstEl = elements[0];
+    const lastEl = elements[elements.length - 1];
+    return {
+        type: 'arrayLiteral',
+        elements,
+        start: firstEl.start,
+        end: lastEl.end,
+        line: firstEl.line,
+        column: firstEl.column,
+    };
 }
 function parseStartCommand(ctx, identifierNode) {
     if (!ctx.match('view')) {
@@ -3211,6 +3356,15 @@ function parseToggleCommand(ctx, identifierNode) {
             args.push(classArg.expression);
             modifiers['as'] = literalModifier(mode);
         }
+        else if (classArg?.type === 'binaryExpression' &&
+            classArg.operator === 'of' &&
+            classArg.left?.type === 'selector' &&
+            typeof classArg.left.value === 'string' &&
+            classArg.left.value.startsWith('*') &&
+            classArg.right) {
+            args.push(classArg.left);
+            modifiers['on'] = classArg.right;
+        }
         else if (classArg) {
             args.push(classArg);
         }
@@ -3388,11 +3542,17 @@ function parseSwapCommand(ctx, identifierNode) {
     const targetExpr = isDelete ? ctx.parseExpression() : parseOneArgument(ctx, [KEYWORDS.WITH]);
     if (targetExpr)
         args.push(targetExpr);
-    if (!isDelete && consumeOptionalKeyword(ctx, KEYWORDS.WITH)) {
+    const isMorph = identifierNode.name === 'morph';
+    if (!isDelete &&
+        (consumeOptionalKeyword(ctx, KEYWORDS.WITH) ||
+            (isMorph && consumeOptionalKeyword(ctx, KEYWORDS.TO)))) {
         const contentExpr = parseOneArgument(ctx, ['using']);
         if (contentExpr)
             modifiers['with'] = contentExpr;
     }
+    if (isMorph && modifiers['with'] === undefined) {
+        ctx.addError("Expected 'to' and the content to morph into");
+    }
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...args)
         .withModifiers({ ...modifiers, ...parseViewTransitionTail(ctx) })
@@ -4153,6 +4313,8 @@ function atArgumentBoundary(ctx, grammar) {
     const next = ctx.peek();
     if (ctx.checkIsCommand() && ctx.peekAt(1)?.value === '(')
         return false;
+    if (isGluedBeepBang(next, ctx.peekAt(1)))
+        return false;
     if (isCommandBoundary(ctx, ['catch', 'finally', 'on']))
         return true;
     return isKeyword(next, [...grammar.markers]);
@@ -4184,10 +4346,13 @@ function parseDeclaredCommand(ctx, commandToken, name, grammar) {
         }
     }
     const commaList = new Set(grammar.commaList ?? []);
+    const namedArgs = new Set(grammar.namedArgs ?? []);
     while (!ctx.isAtEnd() && isKeyword(ctx.peek(), [...grammar.markers])) {
         const keyword = ctx.advance().value;
         const key = ctx.resolveKeyword(keyword).toLowerCase();
-        let value = ctx.parseExpression();
+        let value = namedArgs.has(key) && isNakedNamedArgStart(ctx)
+            ? parseNakedNamedArgs(ctx, () => ctx.parseExpression(), name)
+            : ctx.parseExpression();
         if (value && commaList.has(key) && ctx.check(',')) {
             const elements = [value];
             while (ctx.match(',')) {
@@ -4352,8 +4517,8 @@ function parseFetchCommand(ctx, commandToken) {
         }
         if (ctx.check('with') && !modifiers['with']) {
             ctx.advance();
-            if (isFetchNakedNamedArgStart(ctx)) {
-                modifiers['with'] = parseFetchNakedNamedArgs(ctx);
+            if (isNakedNamedArgStart(ctx)) {
+                modifiers['with'] = parseNakedNamedArgs(ctx, () => ctx.parsePrimary(), 'fetch');
             }
             else {
                 modifiers['with'] = ctx.parsePrimary();
@@ -4388,45 +4553,6 @@ function parseFetchCommand(ctx, commandToken) {
     }
     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) {
@@ -4546,6 +4672,7 @@ function parseTellCommand(ctx, identifierNode) {
     const commands = [];
     while (!ctx.isAtEnd()) {
         if (ctx.checkIsCommand()) {
+            const word = ctx.peek().value;
             try {
                 ctx.advance();
                 const cmd = ctx.parseCommand();
@@ -4556,7 +4683,8 @@ function parseTellCommand(ctx, identifierNode) {
                     break;
                 }
             }
-            catch {
+            catch (error) {
+                ctx.addError(`'${word}' in a tell body failed to parse: ${error instanceof Error ? error.message : String(error)}`);
                 break;
             }
             if (ctx.match(KEYWORDS.AND) || ctx.match(KEYWORDS.THEN)) {
@@ -4705,7 +4833,6 @@ const ONE_EXPR = (syntax) => ({
     markers: [],
     syntax,
 });
-const BEEP = ONE_EXPR('beep! [<expression>, \u2026]');
 const COMMAND_GRAMMAR = {
     append: { positional: 'expression', markers: ['to'], syntax: 'append <value> [to <target>]' },
     prepend: { positional: 'expression', markers: ['to'], syntax: 'prepend <value> [to <target>]' },
@@ -4716,8 +4843,7 @@ const COMMAND_GRAMMAR = {
         syntax: 'make (a|an) <type> [from <args>] [called <name>]',
     },
     throw: { positional: 'primary', markers: [], syntax: 'throw <error>' },
-    'beep!': BEEP,
-    beep: BEEP,
+    beep: ONE_EXPR('beep! [<expression>, \u2026]'),
     blur: ONE_EXPR('blur [<target>]'),
     break: NONE,
     breakpoint: NONE,
@@ -4741,7 +4867,8 @@ const COMMAND_GRAMMAR = {
     render: {
         positional: 'expression',
         markers: ['with'],
-        syntax: 'render <template> [with <variables>]',
+        namedArgs: ['with'],
+        syntax: 'render <template> [with <name>: <value>, \u2026]',
     },
     reset: ONE_EXPR('reset [<form>]'),
     return: ONE_EXPR('return [<value>]'),
@@ -5096,7 +5223,10 @@ class Parser {
         const firstToken = this.peek();
         const prefixEntry = Parser.PRATT_TABLE.get(firstToken.value);
         let left;
-        if (prefixEntry?.prefix) {
+        if (isGluedBeepBang(firstToken, this.tokens[this.current + 1])) {
+            left = this.parseBeepExpression();
+        }
+        else if (prefixEntry?.prefix) {
             const token = this.advance();
             if (this.isAtEnd()) {
                 this.addError(`Expected expression after '${token.value}' operator`);
@@ -5116,6 +5246,9 @@ class Parser {
                     continue;
                 }
             }
+            if (nextToken.value === '*' && this.isSpacedStyleRef(this.current)) {
+                break;
+            }
             const infixEntry = Parser.PRATT_TABLE.get(nextToken.value);
             if (!infixEntry?.infix) {
                 if (STOP_TOKENS.has(nextToken.value) || STOP_DELIMITERS.has(nextToken.value)) {
@@ -5177,6 +5310,35 @@ class Parser {
         this.prattCache.set(cacheKey, { node: left, endPos: this.current });
         return left;
     }
+    parseBeepExpression() {
+        const beepToken = this.advance();
+        this.advance();
+        if (this.isAtEnd()) {
+            this.addError("Expected expression after 'beep!'");
+            return this.createErrorNode();
+        }
+        const operand = this.parseExpressionPratt(Parser.BEEP_OPERAND_BP);
+        return {
+            type: 'unaryExpression',
+            operator: 'beep!',
+            operand,
+            argument: operand,
+            prefix: true,
+            start: beepToken.start,
+            end: this.previous().end,
+            line: beepToken.line,
+            column: beepToken.column,
+        };
+    }
+    isStyleRefStar(i) {
+        const star = this.tokens[i];
+        const name = this.tokens[i + 1];
+        return star?.value === '*' && !!name && name.start === star.end && isIdentifierLike(name);
+    }
+    isSpacedStyleRef(i) {
+        const prev = this.tokens[i - 1];
+        return this.isStyleRefStar(i) && !!prev && prev.end < this.tokens[i].start;
+    }
     tryParseStringPostfix(left, nextToken) {
         const v = nextToken.value;
         let unit = null;
@@ -5379,6 +5541,10 @@ class Parser {
         const isStop = () => this.check('end') || extraStops.some(s => this.check(s));
         debug.parse('\ud83d\udd04 parseCommandListUntilTerminator: Starting (extraStops:', extraStops.join(','), ')');
         while (!this.isAtEnd() && !isStop()) {
+            if (this.checkComment()) {
+                this.advance();
+                continue;
+            }
             debug.parse('\ud83d\udccd Loop iteration, current token:', this.peek().value, 'kind:', this.peek().kind);
             let parsedCommand = false;
             const isCommandToken = this.checkIsCommand();
@@ -5462,7 +5628,7 @@ class Parser {
             debug.parse('\u2705 Found "end", consuming it');
             this.advance();
         }
-        else {
+        else if (!this.atEndOfInput()) {
             debug.parse('\u274c ERROR: Expected "end" but got:', this.peek().value, 'at position:', this.peek().start);
             throw new Error(`Expected "end" to close ${construct} block`);
         }
@@ -5475,7 +5641,7 @@ class Parser {
             if (this.check('end')) {
                 this.advance();
             }
-            else {
+            else if (!this.atEndOfInput()) {
                 throw new Error('Expected "end" to close repeat block');
             }
         }
@@ -5491,7 +5657,10 @@ class Parser {
             this.advance();
         }
         else if (terminator === '') {
-            throw new Error('Expected "end", "else", "until", or "while" to close repeat block');
+            if (!this.atEndOfInput()) {
+                throw new Error('Expected "end", "else", "until", or "while" to close repeat block');
+            }
+            return { commands, terminator: 'end' };
         }
         return { commands, terminator };
     }
@@ -6075,7 +6244,9 @@ class Parser {
     parseTopLevelInitBlock() {
         const pos = this.getPosition();
         const initCommands = this.parseCommandBlock(['end']);
-        this.consume('end', "Expected 'end' after init block");
+        if (!this.match('end') && !this.atEndOfInput() && !this.checkFeatureStart()) {
+            this.consume('end', "Expected 'end' after init block");
+        }
         return {
             type: 'initBlock',
             commands: initCommands,
@@ -6251,10 +6422,29 @@ class Parser {
             ...(sourceExpr.column !== undefined && { column: sourceExpr.column }),
         };
     }
+    isArgumentListOnly(open) {
+        let depth = 0;
+        for (let i = open; i < this.tokens.length; i++) {
+            const token = this.tokens[i];
+            if (token.kind !== 'operator')
+                continue;
+            if (token.value === '(' || token.value === '[' || token.value === '{')
+                depth++;
+            else if (token.value === ')' || token.value === ']' || token.value === '}') {
+                if (--depth === 0)
+                    return i === open + 1;
+            }
+            else if (token.value === ',' && depth === 1)
+                return true;
+        }
+        return false;
+    }
     tryParsePseudoCommand(callExpr, sourceExpr) {
         const methodName = callExpr.callee.name;
         const nextToken = this.peek();
-        const hasPseudoCommandPattern = Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(nextToken.value.toLowerCase()) ||
+        const nextIsArticle = nextToken.value.toLowerCase() === 'the';
+        const hasPseudoCommandPattern = nextIsArticle ||
+            Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(nextToken.value.toLowerCase()) ||
             (isIdentifier(nextToken) && !this.isCommand(nextToken.value)) ||
             isContextVar(nextToken);
         if (!hasPseudoCommandPattern) {
@@ -6280,7 +6470,10 @@ class Parser {
             });
         }
         let preposition;
-        if (Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(this.peek().value.toLowerCase())) {
+        if (nextIsArticle) {
+            this.advance();
+        }
+        else if (Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(this.peek().value.toLowerCase())) {
             preposition = this.advance().value.toLowerCase();
         }
         let targetExpr;
@@ -6444,10 +6637,22 @@ class Parser {
             this.consume(']', "Expected ']' after event condition");
         }
         let target;
+        let targetExpression;
         if (this.match('from')) {
-            const targetToken = this.advance();
-            target = targetToken.value;
-            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed 'from' target: ${target} (kind: ${targetToken.kind})`);
+            if (this.check('the'))
+                this.advance();
+            if (Parser.POSITIONAL_SOURCE_HEADS.has(this.peek().value.toLowerCase())) {
+                const startIndex = this.current;
+                targetExpression = this.parseExpression();
+                target = this.tokens
+                    .slice(startIndex, this.current)
+                    .map(t => t.value)
+                    .join(' ');
+            }
+            else {
+                target = this.advance().value;
+            }
+            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed 'from' target: ${target}`);
             this.parseTemporalKeywordModifiers(modifiers);
         }
         let attributeName;
@@ -6493,7 +6698,7 @@ class Parser {
                 const nextIsOpenParen = this.tokens[this.current + 1]?.value === '(';
                 const commandName = this.peek().value.toLowerCase();
                 const isSpecialBodyCommand = commandName === 'js' || commandName === 'tell';
-                if (nextIsOpenParen && !isSpecialBodyCommand) {
+                if (nextIsOpenParen && !isSpecialBodyCommand && this.isArgumentListOnly(this.current + 1)) {
                     let expr;
                     const savedError = this.error;
                     try {
@@ -6525,7 +6730,7 @@ class Parser {
                     }
                 }
             }
-            else if (this.checkIdentifier()) {
+            else if (this.checkIdentifier() || this.checkEventNamedCall()) {
                 const token = this.peek();
                 if (this.isCommand(token.value)) {
                     const cmd = this.parseCommandWithErrorRecovery();
@@ -6634,6 +6839,7 @@ class Parser {
             ...(eventParams.length > 0 && { args: eventParams }),
             ...(condition && { condition: fromLegacyExpression(condition) }),
             ...(target && { target }),
+            ...(targetExpression && { targetExpression: fromLegacyExpression(targetExpression) }),
             ...(attributeName && { attributeName }),
             ...(watchTarget && { watchTarget: fromLegacyExpression(watchTarget) }),
             ...(customEventSource && { customEventSource }),
@@ -6889,10 +7095,9 @@ class Parser {
     }
     parseCommandCore() {
         const commandToken = this.previous();
-        let commandName = commandToken.value;
+        const commandName = commandToken.value;
         if (commandName === 'beep' && this.check('!')) {
             this.advance();
-            commandName = 'beep!';
         }
         if (commandName === 'fetch') {
             return parseFetchCommand(this.getContext(), commandToken);
@@ -6991,6 +7196,9 @@ class Parser {
             args.push(this.parsePrimary());
         }
         const callNode = this.createCallExpression(createIdentifier(funcName, namePos), args);
+        if (funcName === 'closest' && args.length > 0 && this.match('to')) {
+            callNode.closestTo = this.parseExpression();
+        }
         if (funcName === 'next' || funcName === 'previous') {
             const relativePositional = this.parseRelativePositionalModifiers();
             if (relativePositional) {
@@ -7030,6 +7238,9 @@ class Parser {
     }
     parseTheXofY() {
         const positionalKeywords = ['first', 'last', 'next', 'previous', 'random', 'closest'];
+        if (this.isStyleRefStar(this.current)) {
+            return this.parsePrimary();
+        }
         if (!this.checkIdentifier()) {
             return this.createIdentifier('the');
         }
@@ -7045,7 +7256,7 @@ class Parser {
             return this.createIdentifier(propertyName);
         }
         this.advance();
-        const target = this.parseCall();
+        const target = parseOfOperand(this.makePrattContext(), THE_OF_TARGET_BP);
         return {
             type: 'propertyOfExpression',
             property: { type: 'identifier', name: propertyName },
@@ -7243,6 +7454,13 @@ class Parser {
     checkLiteral() {
         return this.checkPredicate(isLiteral);
     }
+    checkEventNamedCall() {
+        if (this.isAtEnd() || !this.checkIdentifierLike() || this.checkIsCommand())
+            return false;
+        const token = this.peek();
+        const next = this.tokens[this.current + 1];
+        return next?.value === '(' && next.start === token.end;
+    }
     checkIdentifierLike() {
         return this.checkPredicate(isIdentifierLike);
     }
@@ -7351,6 +7569,22 @@ class Parser {
     isAtEnd() {
         return this.current >= this.tokens.length;
     }
+    atEndOfInput() {
+        for (let i = this.current; i < this.tokens.length; i++) {
+            if (!isComment(this.tokens[i]))
+                return false;
+        }
+        return true;
+    }
+    checkFeatureStart() {
+        if (this.isAtEnd())
+            return false;
+        const value = this.peek().value;
+        return (value === 'init' ||
+            value === 'on' ||
+            value === 'def' ||
+            getRegisteredFeature(value) !== undefined);
+    }
     peek() {
         if (this.isAtEnd()) {
             return { kind: 'unknown', value: '', start: 0, end: 0, line: 1, column: 1 };
@@ -7562,6 +7796,7 @@ class Parser {
             match: this.match.bind(this),
             matchOperator: this.matchOperator.bind(this),
             isAtEnd: this.isAtEnd.bind(this),
+            atEndOfInput: this.atEndOfInput.bind(this),
             createIdentifier: this.createIdentifier.bind(this),
             parseExpression: this.parseExpression.bind(this),
             parsePrimary: this.parsePrimary.bind(this),
@@ -7612,7 +7847,15 @@ Parser.POSTFIX_UNARY_OPERATORS = new Set([
     'ignoring case',
 ]);
 Parser.PRATT_TABLE = PARSER_TABLE;
+Parser.BEEP_OPERAND_BP = 80;
 Parser.PSEUDO_COMMAND_PREPOSITIONS = ['from', 'on', 'with', 'into', 'at', 'to'];
+Parser.POSITIONAL_SOURCE_HEADS = new Set([
+    'closest',
+    'next',
+    'previous',
+    'first',
+    'last',
+]);
 
 class FullParserImpl {
     constructor() {