@hyperfixi/core 3.1.1 → 3.3.0

package/dist/index.cjs

@@ -2075,6 +2075,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)],
@@ -2119,7 +2152,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',
@@ -2823,6 +2856,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) {
@@ -3024,6 +3099,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)
@@ -3164,6 +3241,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)) {
@@ -3206,10 +3286,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 {
@@ -3455,7 +3537,7 @@ function parseIfCommand(ctx, commandToken) {
                 }));
             }
         }
-        if (!consumedElseIf && !ctx.isAtEnd()) {
+        if (!consumedElseIf && !ctx.atEndOfInput()) {
             ctx.consume(KEYWORDS.END, "Expected 'end' after if block");
         }
     }
@@ -3480,7 +3562,6 @@ function parseIfCommand(ctx, commandToken) {
         .build();
 }
 function parseForCommand(ctx, commandToken) {
-    const args = [];
     let variable = null;
     let collection = null;
     if (ctx.check(KEYWORDS.EACH)) {
@@ -3523,31 +3604,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();
 }
@@ -3603,86 +3675,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')) {
@@ -3802,6 +3947,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);
         }
@@ -3979,11 +4133,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) })
@@ -4744,6 +4904,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]);
@@ -4775,10 +4937,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(',')) {
@@ -4943,8 +5108,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();
@@ -4979,45 +5144,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) {
@@ -5137,6 +5263,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();
@@ -5147,7 +5274,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)) {
@@ -5296,7 +5424,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>]' },
@@ -5307,8 +5434,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,
@@ -5332,7 +5458,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>]'),
@@ -5687,7 +5814,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`);
@@ -5707,6 +5837,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)) {
@@ -5768,6 +5901,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;
@@ -5970,6 +6132,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();
@@ -6053,7 +6219,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`);
         }
@@ -6066,7 +6232,7 @@ class Parser {
             if (this.check('end')) {
                 this.advance();
             }
-            else {
+            else if (!this.atEndOfInput()) {
                 throw new Error('Expected "end" to close repeat block');
             }
         }
@@ -6082,7 +6248,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 };
     }
@@ -6666,7 +6835,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,
@@ -6842,10 +7013,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) {
@@ -6871,7 +7061,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;
@@ -7035,10 +7228,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;
@@ -7084,7 +7289,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 {
@@ -7116,7 +7321,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();
@@ -7225,6 +7430,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 }),
@@ -7480,10 +7686,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);
@@ -7582,6 +7787,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) {
@@ -7621,6 +7829,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');
         }
@@ -7636,7 +7847,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 },
@@ -7834,6 +8045,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);
     }
@@ -7942,6 +8160,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 };
@@ -8153,6 +8387,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),
@@ -8203,7 +8438,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',
+]);
 function parse(input, options) {
     const tokens = tokenize(input);
     const parser = new Parser(tokens, options, input);
@@ -8408,6 +8651,89 @@ function isDocumentFragment(value) {
         'childNodes' in value);
 }
 
+function beepValues(me, values) {
+    const outputs = values.map(describeBeepValue);
+    const shown = outputs.filter(output => announce(me, output.value));
+    if (shown.length === 0)
+        return outputs;
+    console.group('\ud83d\udd14 beep! Debug Output');
+    for (const output of shown) {
+        console.log(`Value:`, output.value);
+        console.log(`Type:`, output.type);
+        console.log(`Representation:`, output.representation);
+        console.log('---');
+    }
+    console.groupEnd();
+    return outputs;
+}
+function announce(me, value) {
+    const target = me;
+    if (typeof CustomEvent !== 'function' || typeof target?.dispatchEvent !== 'function')
+        return true;
+    return target.dispatchEvent(new CustomEvent('hyperscript:beep', {
+        bubbles: true,
+        cancelable: true,
+        detail: { element: me, value },
+    }));
+}
+function describeBeepValue(value) {
+    return { value, type: typeOf(value), representation: representationOf(value) };
+}
+function typeOf(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (Array.isArray(value))
+        return 'array';
+    if (isHTMLElement$2(value))
+        return 'HTMLElement';
+    if (typeof Element !== 'undefined' && value instanceof Element)
+        return 'Element';
+    if (typeof Node !== 'undefined' && value instanceof Node)
+        return 'Node';
+    if (value instanceof Error)
+        return 'Error';
+    if (value instanceof Date)
+        return 'Date';
+    if (value instanceof RegExp)
+        return 'RegExp';
+    return typeof value;
+}
+function representationOf(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (Array.isArray(value)) {
+        return `Array(${value.length}) [${value
+            .slice(0, 3)
+            .map(v => representationOf(v))
+            .join(', ')}${value.length > 3 ? '...' : ''}]`;
+    }
+    if (isHTMLElement$2(value)) {
+        const el = value;
+        const tag = el.tagName.toLowerCase();
+        const id = el.id ? `#${el.id}` : '';
+        const classes = el.className ? `.${el.className.split(' ').join('.')}` : '';
+        return `<${tag}${id}${classes}/>`;
+    }
+    if (value instanceof Error)
+        return `Error: ${value.message}`;
+    if (typeof value === 'string')
+        return value.length > 50 ? `"${value.substring(0, 47)}..."` : `"${value}"`;
+    if (typeof value === 'object') {
+        try {
+            const keys = Object.keys(value);
+            return `Object {${keys.slice(0, 3).join(', ')}${keys.length > 3 ? '...' : ''}}`;
+        }
+        catch {
+            return '[Object]';
+        }
+    }
+    return String(value);
+}
+
 function convertToNumber(value) {
     if (value === null || value === undefined) {
         return 0;
@@ -8439,6 +8765,16 @@ function convertToNumber(value) {
     }
     return 0;
 }
+function counterAmount(value) {
+    return typeof value === 'number' ? value : parseFloat(String(value));
+}
+function counterValue(value) {
+    if (isHTMLElement$2(value)) {
+        const element = value;
+        return counterValue(element.value || element.textContent);
+    }
+    return value ? counterAmount(value) : 0;
+}
 function getVariableValue(name, context, preferredScope) {
     if (preferredScope === 'element') {
         return getElementVar(context, name);
@@ -8543,35 +8879,39 @@ function setElementPropertyValue(propertyPath, value, context) {
         element[property] = value;
     }
 }
+function isObjectOwner(value) {
+    return (typeof value === 'object' && value !== null && !Array.isArray(value) && !isHTMLElement$2(value));
+}
 function getCurrentNumericValue(target, property, scope, context) {
     if (typeof target === 'number') {
         return target;
     }
     if (isHTMLElement$2(target)) {
         const element = target;
+        if (property?.startsWith('@'))
+            return counterValue(element.getAttribute(property.slice(1)));
         if (property) {
             if (property.startsWith('data-') ||
                 ['id', 'class', 'title', 'alt', 'src', 'href'].includes(property)) {
-                const value = element.getAttribute(property);
-                return convertToNumber(value);
+                return counterValue(element.getAttribute(property));
             }
             else {
-                const value = element[property];
-                return convertToNumber(value);
+                return counterValue(element[property]);
             }
         }
         else {
-            const value = element.value || element.textContent;
-            return convertToNumber(value);
+            return counterValue(element);
         }
     }
+    if (property && isObjectOwner(target)) {
+        return counterValue(target[property]);
+    }
     if (typeof target === 'string') {
         if (scope === 'element') {
-            return convertToNumber(getVariableValue(target, context, 'element'));
+            return counterValue(getVariableValue(target, context, 'element'));
         }
         if (scope === 'global') {
-            const value = getVariableValue(target, context, 'global');
-            return convertToNumber(value);
+            return counterValue(getVariableValue(target, context, 'global'));
         }
         if (target.includes('.')) {
             return getElementPropertyValue(target, context);
@@ -8585,14 +8925,17 @@ function getCurrentNumericValue(target, property, scope, context) {
         else if (target === 'you' && context.you) {
             return convertToNumber(context.you.value || 0);
         }
-        const value = getVariableValue(target, context);
-        return convertToNumber(value);
+        return counterValue(getVariableValue(target, context));
     }
-    return convertToNumber(target);
+    return counterValue(target);
 }
 function setTargetValue(target, property, scope, newValue, context) {
     if (isHTMLElement$2(target)) {
         const element = target;
+        if (property?.startsWith('@')) {
+            element.setAttribute(property.slice(1), String(newValue));
+            return;
+        }
         if (property) {
             if (property.startsWith('data-') ||
                 ['id', 'class', 'title', 'alt', 'src', 'href'].includes(property)) {
@@ -8612,6 +8955,10 @@ function setTargetValue(target, property, scope, newValue, context) {
         }
         return;
     }
+    if (property && isObjectOwner(target)) {
+        target[property] = newValue;
+        return;
+    }
     if (typeof target === 'string') {
         if (scope === 'element') {
             setVariableValue(target, newValue, context, 'element');
@@ -9040,13 +9387,6 @@ function isFunction(value) {
 function isInputElement$1(el) {
     return (el !== null && typeof el === 'object' && 'tagName' in el && el.tagName === 'INPUT');
 }
-function isFormElement$1(el) {
-    if (el === null || typeof el !== 'object' || !('tagName' in el)) {
-        return false;
-    }
-    const tag = el.tagName;
-    return tag === 'INPUT' || tag === 'SELECT' || tag === 'TEXTAREA';
-}
 function isHTMLElement$1(el) {
     return (el !== null &&
         typeof el === 'object' &&
@@ -9106,7 +9446,7 @@ const SPECIAL_DOM_PROPERTIES = {
     innertext: el => el.textContent?.trim(),
     innerHTML: el => el.innerHTML,
     outerhtml: el => el.outerHTML,
-    value: el => (isFormElement$1(el) ? el.value : undefined),
+    value: el => ('value' in el ? el.value : undefined),
     checked: el => (isInputElement$1(el) ? el.checked : undefined),
     disabled: el => ('disabled' in el ? el.disabled : undefined),
     selected: el => (isOptionElement$1(el) ? el.selected : undefined),
@@ -9774,14 +10114,15 @@ const closestExpression = {
         if (typeof selector !== 'string') {
             throw new Error('closest requires a string selector');
         }
-        if (!context.me) {
+        const start = args.length > 1 ? args[1] : context.me;
+        if (!(start instanceof Element)) {
             return null;
         }
-        return context.me.closest(selector);
+        return start.closest(selector);
     },
     validate(args) {
-        if (args.length !== 1) {
-            return 'closest requires exactly 1 argument (selector)';
+        if (args.length !== 1 && args.length !== 2) {
+            return 'closest requires a selector and, optionally, the element to start from';
         }
         const arg = args[0];
         if (typeof arg === 'string')
@@ -11281,7 +11622,7 @@ const isEmptyExpression = {
         else if (value instanceof Node || value instanceof Element)
             result = false;
         else if (isObject(value))
-            result = Object.keys(value).length === 0;
+            result = value.length === 0;
         else
             result = false;
         return result;
@@ -12405,11 +12746,16 @@ async function evaluateBinaryExpression(node, context) {
                 }
             }
         }
-        if (leftNode?.type === 'selector' && leftNode.fromQuery && typeof leftNode.value === 'string') {
+        if (leftNode?.type === 'selector' &&
+            typeof leftNode.value === 'string' &&
+            (leftNode.fromQuery || (operator === 'in' && leftNode.value.startsWith('.')))) {
             const root = await evaluateAST(node.right, context);
             const scope = root && typeof root.querySelectorAll === 'function' ? root : null;
             if (scope) {
-                return Array.from(scope.querySelectorAll(leftNode.value));
+                const query = leftNode.fromQuery
+                    ? leftNode.value
+                    : escapeSelectorForQuery(leftNode, leftNode.value);
+                return Array.from(scope.querySelectorAll(query));
             }
         }
     }
@@ -12421,6 +12767,12 @@ async function evaluateBinaryExpression(node, context) {
         return getExpr(context, 'styleRef').evaluate(context, leftNode.value.slice(1), el);
     }
     if (operator === 'of') {
+        if (leftNode?.type === 'attributeAccess') {
+            const target = await evaluateAST(node.right, context);
+            if (target == null)
+                return undefined;
+            return getExpr(context, 'possessive').evaluate(context, target, `@${leftNode.attributeName}`);
+        }
         const path = propertyPathOf(node.left);
         if (path) {
             const target = await evaluateAST(node.right, context);
@@ -12428,6 +12780,10 @@ async function evaluateBinaryExpression(node, context) {
             for (const seg of path) {
                 if (cur == null)
                     return undefined;
+                if (isMappableCollection(cur) && !(seg in cur)) {
+                    cur = await getExpr(context, 'possessive').evaluate(context, cur, seg);
+                    continue;
+                }
                 cur = isElement(cur) ? getElementProperty$1(cur, seg) : cur[seg];
             }
             return typeof cur === 'function' ? cur.bind(target) : cur;
@@ -12452,26 +12808,21 @@ async function evaluateBinaryExpression(node, context) {
     const R = node.ignoringCase ? applyCI(right) : right;
     switch (operator) {
         case '+': {
-            let addLeft = left;
-            let addRight = right;
             if (node.coerceNumeric) {
-                if (typeof addLeft === 'string')
-                    addLeft = convertToNumber(addLeft);
-                if (typeof addRight === 'string')
-                    addRight = convertToNumber(addRight);
+                return counterValue(left) + counterAmount(right);
             }
-            if (typeof addLeft === 'string' || typeof addRight === 'string') {
-                return String(addLeft ?? '') + String(addRight ?? '');
+            if (typeof left === 'string' || typeof right === 'string') {
+                return String(left ?? '') + String(right ?? '');
             }
-            if (Array.isArray(addLeft)) {
-                return Array.isArray(addRight) ? [...addLeft, ...addRight] : [...addLeft, addRight];
+            if (Array.isArray(left)) {
+                return Array.isArray(right) ? [...left, ...right] : [...left, right];
             }
-            return unwrapTypedResult(await getExpr(context, 'addition').evaluate(context, {
-                left: addLeft,
-                right: addRight,
-            }));
+            return unwrapTypedResult(await getExpr(context, 'addition').evaluate(context, { left, right }));
         }
         case '-':
+            if (node.coerceNumeric) {
+                return counterValue(left) - counterAmount(right);
+            }
             return unwrapTypedResult(await getExpr(context, 'subtraction').evaluate(context, { left, right }));
         case '*':
             return unwrapTypedResult(await getExpr(context, 'multiplication').evaluate(context, { left, right }));
@@ -12729,9 +13080,8 @@ async function evaluatePropertyOfExpressionNode(node, context) {
     }
     const propertyName = propertyNode.name;
     const target = await evaluateAST(node.target, context);
-    if (target == null) {
-        throw new Error(`Cannot access property "${propertyName}" of ${target}`);
-    }
+    if (target == null)
+        return undefined;
     return getExpr(context, 'possessive').evaluate(context, target, propertyName);
 }
 async function evaluateTemplateLiteralNode(node, context) {
@@ -12849,6 +13199,9 @@ async function evaluateUnaryExpression(node, context) {
         case 'not':
         case '!':
             return logicalExpressions.not.evaluate(context, value);
+        case 'beep!':
+            beepValues(context.me, [value]);
+            return value;
         case 'no':
             return logicalExpressions.no.evaluate(context, value);
         case '-':
@@ -12938,6 +13291,10 @@ async function evaluateCallExpression(node, context) {
         const args = await resolveCallArgs(node.arguments, funcName, context);
         switch (funcName) {
             case 'closest':
+                if (node.closestTo) {
+                    const start = unwrapElement(await evaluateAST(node.closestTo, context)) ?? null;
+                    return referencesExpressions.closest.evaluate(context, args[0], start);
+                }
                 return referencesExpressions.closest.evaluate(context, ...args);
             case 'previous':
             case 'next': {
@@ -14324,12 +14681,23 @@ class RuntimeBase {
         debug.runtime(`BEHAVIOR: Finished installing ${behaviorName}`);
     }
     async executeEventHandler(node, context) {
-        const { event, events, commands, target, args, selector, condition, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler, } = node;
+        const { event, events, commands, target, targetExpression, args, selector, condition, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler, } = node;
         const eventNames = events && events.length > 0 ? events : [event];
         debug.runtime(`BEHAVIOR: executeEventHandler: event='${event}', target='${target}'`);
         let targets = [];
         let globalTarget = null;
-        if (target) {
+        if (targetExpression) {
+            const resolved = await this.execute(targetExpression, context);
+            if (resolved === window)
+                globalTarget = window;
+            else if (resolved === document)
+                globalTarget = document;
+            else if (this.isElement(resolved))
+                targets = [resolved];
+            else if (Array.isArray(resolved))
+                targets = resolved.filter(el => this.isElement(el));
+        }
+        else if (target) {
             const targetLower = typeof target === 'string' ? target.toLowerCase() : '';
             if (targetLower === 'window' || targetLower === 'the window') {
                 globalTarget = window;
@@ -16350,14 +16718,83 @@ function parseAttribute(expression) {
     if (trimmed.startsWith('@')) {
         return { name: trimmed.substring(1).trim() };
     }
-    throw new Error(`Invalid attribute syntax: ${expression}`);
-}
-function parseAttributeName(expression) {
-    return parseAttribute(expression).name;
+    throw new Error(`Invalid attribute syntax: ${expression}`);
+}
+function parseAttributeName(expression) {
+    return parseAttribute(expression).name;
+}
+function parseAttributeWithValue(expression) {
+    const result = parseAttribute(expression);
+    return { name: result.name, value: result.value ?? '' };
+}
+
+function _parseDurationComponents(value) {
+    const trimmed = value.trim();
+    const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(s|ms|sec|seconds?|milliseconds?)?$/i);
+    if (!match) {
+        return null;
+    }
+    const number = parseFloat(match[1]);
+    const unit = (match[2] || 'ms').toLowerCase();
+    if (unit === 'ms' || unit === 'millisecond' || unit === 'milliseconds') {
+        return { number, milliseconds: Math.floor(number) };
+    }
+    else if (unit === 's' || unit === 'sec' || unit === 'second' || unit === 'seconds') {
+        return { number, milliseconds: Math.floor(number * 1000) };
+    }
+    return null;
+}
+function parseDuration(value, defaultMs = 300) {
+    if (typeof value === 'number') {
+        return Math.max(0, Math.floor(value));
+    }
+    if (typeof value === 'string') {
+        const result = _parseDurationComponents(value);
+        return result ? result.milliseconds : defaultMs;
+    }
+    return defaultMs;
+}
+function parseDurationStrict(value) {
+    if (typeof value === 'number') {
+        if (value < 0)
+            throw new Error('Duration must be >= 0');
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const result = _parseDurationComponents(value);
+        if (!result) {
+            throw new Error(`Invalid duration format: "${value}"`);
+        }
+        return result.milliseconds;
+    }
+    throw new Error(`Invalid duration type: ${typeof value}`);
+}
+function parseCSSDurations(durationString) {
+    if (!durationString || durationString === 'none') {
+        return [0];
+    }
+    return durationString.split(',').map(duration => {
+        const value = parseFloat(duration.trim());
+        if (isNaN(value))
+            return 0;
+        if (duration.includes('s') && !duration.includes('ms')) {
+            return value * 1000;
+        }
+        return value;
+    });
+}
+function calculateMaxAnimationTime(durations, delays) {
+    let maxTime = 0;
+    for (let i = 0; i < durations.length; i++) {
+        const duration = durations[i] || 0;
+        const delay = delays[i] || 0;
+        const totalTime = duration + delay;
+        maxTime = Math.max(maxTime, totalTime);
+    }
+    return maxTime;
 }
-function parseAttributeWithValue(expression) {
-    const result = parseAttribute(expression);
-    return { name: result.name, value: result.value ?? '' };
+function camelToKebab(str) {
+    return str.replace(/([A-Z])/g, '-$1').toLowerCase();
 }
 
 function batchApply(targets, operation) {
@@ -16425,15 +16862,18 @@ function toggleAttribute(element, name, value) {
         }
     }
 }
+function toCssPropertyName(property) {
+    return property.startsWith('--') ? property : camelToKebab(property);
+}
 function batchSetStyles(targets, styles) {
     const entries = Object.entries(styles);
     return batchApplyItems(targets, entries, (element, [property, value]) => {
-        element.style.setProperty(property, value);
+        element.style.setProperty(toCssPropertyName(property), value);
     });
 }
 function batchRemoveStyles(targets, properties) {
     return batchApplyItems(targets, properties, (element, property) => {
-        element.style.removeProperty(property);
+        element.style.removeProperty(toCssPropertyName(property));
     });
 }
 
@@ -17099,75 +17539,6 @@ let RemoveCommand = (() => {
 })();
 const createRemoveCommand = createFactory(RemoveCommand);
 
-function _parseDurationComponents(value) {
-    const trimmed = value.trim();
-    const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(s|ms|sec|seconds?|milliseconds?)?$/i);
-    if (!match) {
-        return null;
-    }
-    const number = parseFloat(match[1]);
-    const unit = (match[2] || 'ms').toLowerCase();
-    if (unit === 'ms' || unit === 'millisecond' || unit === 'milliseconds') {
-        return { number, milliseconds: Math.floor(number) };
-    }
-    else if (unit === 's' || unit === 'sec' || unit === 'second' || unit === 'seconds') {
-        return { number, milliseconds: Math.floor(number * 1000) };
-    }
-    return null;
-}
-function parseDuration(value, defaultMs = 300) {
-    if (typeof value === 'number') {
-        return Math.max(0, Math.floor(value));
-    }
-    if (typeof value === 'string') {
-        const result = _parseDurationComponents(value);
-        return result ? result.milliseconds : defaultMs;
-    }
-    return defaultMs;
-}
-function parseDurationStrict(value) {
-    if (typeof value === 'number') {
-        if (value < 0)
-            throw new Error('Duration must be >= 0');
-        return Math.floor(value);
-    }
-    if (typeof value === 'string') {
-        const result = _parseDurationComponents(value);
-        if (!result) {
-            throw new Error(`Invalid duration format: "${value}"`);
-        }
-        return result.milliseconds;
-    }
-    throw new Error(`Invalid duration type: ${typeof value}`);
-}
-function parseCSSDurations(durationString) {
-    if (!durationString || durationString === 'none') {
-        return [0];
-    }
-    return durationString.split(',').map(duration => {
-        const value = parseFloat(duration.trim());
-        if (isNaN(value))
-            return 0;
-        if (duration.includes('s') && !duration.includes('ms')) {
-            return value * 1000;
-        }
-        return value;
-    });
-}
-function calculateMaxAnimationTime(durations, delays) {
-    let maxTime = 0;
-    for (let i = 0; i < durations.length; i++) {
-        const duration = durations[i] || 0;
-        const delay = delays[i] || 0;
-        const totalTime = duration + delay;
-        maxTime = Math.max(maxTime, totalTime);
-    }
-    return maxTime;
-}
-function camelToKebab(str) {
-    return str.replace(/([A-Z])/g, '-$1').toLowerCase();
-}
-
 function detectSmartElementType(elements) {
     if (elements.length === 0)
         return null;
@@ -18037,7 +18408,11 @@ let PutCommand = (() => {
             }
             if (isInsertableNode(v))
                 return v;
-            return v == null ? '' : String(v);
+            if (v == null)
+                return 'null';
+            if (Array.isArray(v))
+                return arrayFragment(v);
+            return String(v);
         }
         looksLikeCss(s) {
             if (!s)
@@ -18122,6 +18497,19 @@ let PutCommand = (() => {
     })();
     return PutCommand = _classThis;
 })();
+function arrayFragment(items) {
+    const fragment = document.createDocumentFragment();
+    for (const item of items) {
+        if (isInsertableNode(item)) {
+            fragment.append(item);
+            continue;
+        }
+        const template = document.createElement('template');
+        template.innerHTML = item === null ? '' : String(item);
+        fragment.append(template.content);
+    }
+    return fragment;
+}
 const createPutCommand = createFactory(PutCommand);
 
 const HTML_ESCAPE = {
@@ -19339,10 +19727,29 @@ const STRATEGY_KEYWORDS = {
     innermorph: 'morph',
     outermorph: 'morphOuter',
 };
+function loneRootWithTag(content, tagName) {
+    let root;
+    if (typeof content === 'string') {
+        const template = document.createElement('template');
+        template.innerHTML = content;
+        root = template.content.firstElementChild;
+        if (!root || root.nextElementSibling)
+            return null;
+    }
+    else {
+        root = content.cloneNode(true);
+    }
+    return root.tagName === tagName && isHTMLElement$2(root) ? root : null;
+}
 function executeSwap(target, content, strategy, morphOptions) {
     const contentStr = content !== null && !isHTMLElement$2(content) ? content : '';
     const contentEl = isHTMLElement$2(content) ? content : null;
     switch (strategy) {
+        case 'morphMerge': {
+            const root = content !== null ? loneRootWithTag(content, target.tagName) : null;
+            executeSwap(target, root ?? content, root ? 'morphOuter' : 'morph', morphOptions);
+            break;
+        }
         case 'morph':
             if (content !== null) {
                 try {
@@ -19632,7 +20039,7 @@ let MorphCommand = (() => {
             if (args.length === 0 && modifiers.with === undefined) {
                 throw new Error('[HyperFixi] morph: command requires arguments');
             }
-            const strategy = literalText(modifiers.strategy)?.toLowerCase() === 'over' ? 'morphOuter' : 'morph';
+            const strategy = literalText(modifiers.strategy)?.toLowerCase() === 'over' ? 'morphOuter' : 'morphMerge';
             const useViewTransition = modifiers.viewTransition !== undefined;
             const targetNode = modifiers.on !== undefined ? modifiers.on : args[0];
             const contentNode = modifiers.with !== undefined
@@ -20938,6 +21345,19 @@ async function resolveWriteTarget(node, evaluator, context, options) {
         }
         return { kind: 'property', target: property };
     }
+    if (options.ofAndObjectProperty) {
+        const access = ofOrPossessiveAccess(n);
+        if (access) {
+            const owner = await evaluator.evaluate(access.owner, context);
+            const element = Array.isArray(owner) ? owner[0] : owner;
+            if (access.isOf && isHTMLElement$2(element)) {
+                return { kind: 'property', target: { element, property: access.name } };
+            }
+            if (isObjectOwner(owner)) {
+                return { kind: 'member', container: owner, property: access.name };
+            }
+        }
+    }
     if (options.bareReference &&
         (nodeType === 'identifier' || nodeType === 'variable' || nodeType === 'symbol') &&
         typeof n.name === 'string') {
@@ -20947,6 +21367,19 @@ async function resolveWriteTarget(node, evaluator, context, options) {
     }
     return null;
 }
+function ofOrPossessiveAccess(n) {
+    const [owner, property, isOf] = n.type === 'possessiveExpression'
+        ? [n.object, n.property, false]
+        : n.type === 'propertyOfExpression'
+            ? [n.target, n.property, false]
+            : n.type === 'binaryExpression' && n.operator === 'of'
+                ? [n.right, n.left, true]
+                : [undefined, undefined, false];
+    const name = property?.name;
+    if (!owner || typeof name !== 'string' || !/^[A-Za-z_$][\w$]*$/.test(name))
+        return null;
+    return { owner, name, isOf };
+}
 
 function toSetInput(target, value) {
     switch (target.kind) {
@@ -20968,10 +21401,18 @@ function toSetInput(target, value) {
                 property: target.target.property,
                 value,
             };
+        case 'member':
+            return {
+                type: 'member-assignment',
+                container: target.container,
+                property: target.property,
+                value,
+            };
         default:
             throw new Error(`set: unrequested write-target rung '${target.kind}'`);
     }
 }
+const SET_RUNGS = { nodeWriters: true, styleSplit: true, ofAndObjectProperty: true };
 let SetCommand = (() => {
     let _classDecorators = [command({ name: 'set' })];
     let _classDescriptor;
@@ -20990,8 +21431,7 @@ let SetCommand = (() => {
             const argScope = firstArg?.scope;
             const writeTarget = await resolveWriteTarget(firstArg, evaluator, context, {
                 scopeElements: () => this.resolveTargets(raw.modifiers.on, evaluator, context),
-                nodeWriters: true,
-                styleSplit: true,
+                ...SET_RUNGS,
             });
             if (writeTarget) {
                 return toSetInput(writeTarget, await this.extractValue(raw, evaluator, context));
@@ -21317,12 +21757,30 @@ function getNodeType(node) {
         return 'unknown';
     return node.type || 'unknown';
 }
+function propertyTarget(node) {
+    const n = node;
+    const owner = n.type === 'propertyOfExpression'
+        ? n.target
+        : n.type === 'possessiveExpression' ||
+            n.type === 'memberExpression' ||
+            n.type === 'propertyAccess'
+            ? n.object
+            : undefined;
+    if (!owner || n.computed)
+        return null;
+    const p = n.property;
+    const name = typeof p === 'string' ? p : typeof p?.name === 'string' ? p.name : undefined;
+    if (!name || !/^[A-Za-z_$][\w$-]*$/.test(name))
+        return null;
+    return { owner, name };
+}
 async function parseNumericTargetInput(raw, evaluator, context, commandName) {
     if (!raw.args || raw.args.length === 0) {
         throw new Error(`${commandName} command requires a target`);
     }
     const targetArg = raw.args[0];
     let target;
+    let property;
     let extractedScope;
     let customWrite;
     const nodeType = getNodeType(targetArg);
@@ -21337,7 +21795,25 @@ async function parseNumericTargetInput(raw, evaluator, context, commandName) {
     }
     else {
         const writer = getRegisteredNodeWriter(nodeType);
-        if (writer) {
+        const attribute = writer
+            ? null
+            : await resolveAttributeWriteTarget(targetArg, evaluator, context, async () => context.me ? [context.me] : []);
+        const prop = writer || attribute ? null : propertyTarget(targetArg);
+        const owner = prop ? await evaluator.evaluate(prop.owner, context) : undefined;
+        const ownerElement = Array.isArray(owner) ? owner[0] : owner;
+        if (attribute?.elements[0]) {
+            target = attribute.elements[0];
+            property = `@${attribute.name}`;
+        }
+        else if (prop && isHTMLElement$2(ownerElement)) {
+            target = ownerElement;
+            property = prop.name;
+        }
+        else if (prop && isObjectOwner(owner)) {
+            target = owner;
+            property = prop.name;
+        }
+        else if (writer) {
             const currentRaw = await evaluator.evaluate(targetArg, context);
             const currentValue = typeof currentRaw === 'number'
                 ? currentRaw
@@ -21375,24 +21851,22 @@ async function parseNumericTargetInput(raw, evaluator, context, commandName) {
             if (typeof evaluated === 'number') {
                 amount = evaluated;
             }
+            else if (evaluated == null) {
+                amount = NaN;
+            }
         }
     }
     const byModifier = raw.modifiers?.by;
     if (byModifier) {
-        const byValue = byModifier.value;
-        if (getNodeType(byModifier) === 'literal' && typeof byValue === 'number') {
-            amount = byValue;
-        }
-        else if (getNodeType(byModifier) !== 'literal') {
-            const evaluated = await evaluator.evaluate(byModifier, context);
-            if (typeof evaluated === 'number') {
-                amount = evaluated;
-            }
-        }
+        const value = getNodeType(byModifier) === 'literal'
+            ? byModifier.value
+            : await evaluator.evaluate(byModifier, context);
+        amount = counterAmount(value);
     }
     return {
         target,
         amount,
+        ...(property && { property }),
         ...(scope && { scope }),
         ...(customWrite && { customWrite }),
     };
@@ -21415,7 +21889,7 @@ let NumericModifyCommand = (() => {
         async execute(input, context) {
             const { target, property, scope, amount = 1, operation = 'increment', customWrite } = input;
             if (customWrite) {
-                const delta = isFinite(amount) ? amount : 1;
+                const delta = amount;
                 const newValue = operation === 'increment'
                     ? customWrite.currentValue + delta
                     : customWrite.currentValue - delta;
@@ -21429,8 +21903,7 @@ let NumericModifyCommand = (() => {
                 newValue = NaN;
             }
             else {
-                const delta = isFinite(amount) ? amount : 1;
-                newValue = operation === 'increment' ? currentValue + delta : currentValue - delta;
+                newValue = operation === 'increment' ? currentValue + amount : currentValue - amount;
             }
             setTargetValue(target, property, scope, newValue, context);
             Object.assign(context, { it: newValue });
@@ -22538,7 +23011,10 @@ function createUntilLoopConfig(conditionExpr, evaluateCondition, context, indexV
     };
     const config = {
         type: 'until',
-        shouldContinue: () => !evaluateCondition(conditionExpr, context),
+        shouldContinue: () => {
+            const met = evaluateCondition(conditionExpr, context);
+            return met instanceof Promise ? met.then(value => !value) : !met;
+        },
     };
     return { config, iterCtx };
 }
@@ -22574,7 +23050,7 @@ function createForeverLoopConfig(indexVariable, maxIterations = 10000) {
     return { config, iterCtx };
 }
 
-async function slotText(node, evaluator, context) {
+async function slotText$1(node, evaluator, context) {
     if (!node)
         return undefined;
     const n = node;
@@ -22587,6 +23063,18 @@ async function slotText(node, evaluator, context) {
     const v = await evaluator.evaluate(node, context);
     return typeof v === 'string' ? v : undefined;
 }
+function isEventTarget(value) {
+    return typeof value?.addEventListener === 'function';
+}
+async function evaluateLoopCondition(condition, context) {
+    if (typeof condition === 'function')
+        return Boolean(await condition());
+    return evaluateCondition(condition, context);
+}
+function loopCount(value) {
+    const count = Number(value);
+    return Number.isNaN(count) ? 0 : count;
+}
 let RepeatCommand = (() => {
     let _classDecorators = [command({ name: 'repeat' })];
     let _classDescriptor;
@@ -22624,7 +23112,7 @@ let RepeatCommand = (() => {
                 }
             }
             const m = raw.modifiers ?? {};
-            const text = (node) => slotText(node, evaluator, context);
+            const text = (node) => slotText$1(node, evaluator, context);
             const loopType = (await text(m.loopType)) ?? null;
             const bottomTested = m.bottomTested
                 ? (await evaluator.evaluate(m.bottomTested, context))
@@ -22644,17 +23132,24 @@ let RepeatCommand = (() => {
                 };
             }
             if (loopType === 'times' || m.times) {
-                const countValue = m.times && (await evaluator.evaluate(m.times, context));
-                const count = typeof countValue === 'number' ? countValue : parseInt(String(countValue), 10);
-                if (isNaN(count))
+                if (!m.times)
                     throw new Error('times loops require a count number');
+                const count = loopCount(await evaluator.evaluate(m.times, context));
                 return { type: 'times', count, indexVariable, commands, elseCommands };
             }
             if (loopType === 'while' || m.while) {
                 const condition = m.while;
                 if (!condition)
                     throw new Error('while loops require a condition');
-                return { type: 'while', condition, indexVariable, commands, elseCommands, bottomTested };
+                const check = () => evaluator.evaluate(condition, context);
+                return {
+                    type: 'while',
+                    condition: check,
+                    indexVariable,
+                    commands,
+                    elseCommands,
+                    bottomTested,
+                };
             }
             if (loopType === 'until-event' || m.event) {
                 const eventName = await text(m.event);
@@ -22672,7 +23167,7 @@ let RepeatCommand = (() => {
                     }
                     else {
                         const target = await evaluator.evaluate(m.from, context);
-                        if (target instanceof EventTarget)
+                        if (isEventTarget(target))
                             eventTarget = target;
                         else if (target === 'document')
                             eventTarget = document;
@@ -22693,7 +23188,15 @@ let RepeatCommand = (() => {
                 const condition = m.until;
                 if (!condition)
                     throw new Error('until loops require a condition');
-                return { type: 'until', condition, indexVariable, commands, elseCommands, bottomTested };
+                const check = () => evaluator.evaluate(condition, context);
+                return {
+                    type: 'until',
+                    condition: check,
+                    indexVariable,
+                    commands,
+                    elseCommands,
+                    bottomTested,
+                };
             }
             if (loopType === 'forever') {
                 return { type: 'forever', indexVariable, commands, elseCommands };
@@ -22711,10 +23214,10 @@ let RepeatCommand = (() => {
                     ({ config, iterCtx } = createTimesLoopConfig(count, indexVariable));
                     break;
                 case 'while':
-                    ({ config, iterCtx } = createWhileLoopConfig(condition, evaluateCondition, context, indexVariable));
+                    ({ config, iterCtx } = createWhileLoopConfig(condition, evaluateLoopCondition, context, indexVariable));
                     break;
                 case 'until':
-                    ({ config, iterCtx } = createUntilLoopConfig(condition, evaluateCondition, context, indexVariable));
+                    ({ config, iterCtx } = createUntilLoopConfig(condition, evaluateLoopCondition, context, indexVariable));
                     break;
                 case 'until-event':
                     ({ config, iterCtx } = createUntilEventLoopConfig(eventName, eventTarget, indexVariable));
@@ -23745,6 +24248,29 @@ function namedPropertyOf(node) {
     }
     return null;
 }
+const RESTORE_KEYWORDS = new Set(['initial', 'inherit', 'unset', 'revert']);
+function elementsOf(value) {
+    if (Array.isArray(value) || isNodeList(value)) {
+        return Array.from(value).filter(isHTMLElement$2);
+    }
+    return isHTMLElement$2(value) ? [value] : [];
+}
+async function valueOf(node, evaluator, context) {
+    const value = await evaluator.evaluate(node, context);
+    const name = node.name;
+    if (value === undefined && node.type === 'identifier' && typeof name === 'string')
+        return name;
+    return value;
+}
+function longestTransitionMs(css) {
+    let longest;
+    for (const item of css.split(',')) {
+        const times = [...item.matchAll(/(\d*\.?\d+)(ms|s)\b/g)].map(m => parseFloat(m[1]) * (m[2] === 's' ? 1000 : 1));
+        if (times.length > 0)
+            longest = Math.max(longest ?? 0, times[0] + (times[1] ?? 0));
+    }
+    return longest;
+}
 let TransitionCommand = (() => {
     let _classDecorators = [command({ name: 'transition' })];
     let _classDescriptor;
@@ -23760,11 +24286,10 @@ let TransitionCommand = (() => {
             let property;
             let target;
             const firstArg = await evaluator.evaluate(raw.args[0], context);
-            const asElement = (value) => Array.isArray(value) || isNodeList(value) ? value[0] : value;
-            const firstAsElement = asElement(firstArg);
-            if (isHTMLElement$2(firstAsElement) ||
+            const owners = elementsOf(firstArg);
+            if (owners.length > 0 ||
                 (typeof firstArg === 'string' && /^[#.]|^(?:me|it|you)$/.test(firstArg))) {
-                target = firstAsElement;
+                target = owners.length === 1 ? owners[0] : owners.length > 1 ? owners : firstArg;
                 property = String(await evaluator.evaluate(raw.args[1], context));
             }
             else if (raw.args.length >= 2) {
@@ -23776,9 +24301,9 @@ let TransitionCommand = (() => {
                     throw new Error('transition requires a CSS property');
                 property = named.property;
                 if (named.objectNode !== undefined) {
-                    const owner = asElement(await evaluator.evaluate(named.objectNode, context));
-                    if (isHTMLElement$2(owner))
-                        target = owner;
+                    const owner = elementsOf(await evaluator.evaluate(named.objectNode, context));
+                    if (owner.length > 0)
+                        target = owner.length === 1 ? owner[0] : owner;
                 }
             }
             else {
@@ -23789,60 +24314,131 @@ let TransitionCommand = (() => {
             }
             if (!raw.modifiers?.to)
                 throw new Error('transition requires "to <value>"');
-            let value = await evaluator.evaluate(raw.modifiers.to, context);
-            if (value === undefined && raw.modifiers.to.type === 'identifier') {
-                value = raw.modifiers.to.name;
-            }
-            const result = { property, value: value };
+            const result = {
+                property,
+                value: await valueOf(raw.modifiers.to, evaluator, context),
+            };
             if (target !== undefined)
                 result.target = target;
+            if (raw.modifiers?.from)
+                result.from = await valueOf(raw.modifiers.from, evaluator, context);
+            if (raw.modifiers?.pairs) {
+                result.pairs = await this.laterPairs(raw.modifiers.pairs, evaluator, context);
+            }
             if (raw.modifiers?.over)
                 result.duration = await evaluator.evaluate(raw.modifiers.over, context);
             if (raw.modifiers?.with)
                 result.timingFunction = String(await evaluator.evaluate(raw.modifiers.with, context));
+            if (raw.modifiers?.using)
+                result.using = String(await evaluator.evaluate(raw.modifiers.using, context));
             return result;
         }
+        async laterPairs(node, evaluator, context) {
+            const pairs = [];
+            for (const pairNode of node.elements ?? []) {
+                const fields = new Map();
+                const properties = pairNode
+                    .properties ?? [];
+                for (const { key, value } of properties) {
+                    if (typeof key.name === 'string')
+                        fields.set(key.name, value);
+                }
+                const propertyNode = fields.get('property');
+                const toNode = fields.get('to');
+                if (!propertyNode || !toNode)
+                    throw new Error('transition requires property and value');
+                const pair = {
+                    property: String(await evaluator.evaluate(propertyNode, context)),
+                    value: await valueOf(toNode, evaluator, context),
+                };
+                const ownerNode = fields.get('owner');
+                if (ownerNode) {
+                    const owners = elementsOf(await evaluator.evaluate(ownerNode, context));
+                    if (owners.length === 0)
+                        throw new Error('transition: target element not found');
+                    pair.target = owners.length === 1 ? owners[0] : owners;
+                }
+                const fromNode = fields.get('from');
+                if (fromNode)
+                    pair.from = await valueOf(fromNode, evaluator, context);
+                pairs.push(pair);
+            }
+            return pairs;
+        }
         async execute(input, context) {
-            let { property } = input;
-            const { target, value, duration: durationInput, timingFunction } = input;
-            if (property.startsWith('*'))
-                property = property.substring(1);
-            property = camelToKebab(property);
-            const targetElement = resolveElement(target, context, 'transition');
-            const duration = parseDuration(durationInput, 300);
-            const fromValue = getComputedStyle(targetElement).getPropertyValue(property);
-            const originalTransition = targetElement.style.transition;
-            const transitionProp = `${property} ${duration}ms ${timingFunction || 'ease'}`;
-            targetElement.style.transition = originalTransition
-                ? `${originalTransition}, ${transitionProp}`
-                : transitionProp;
-            let toValue = String(value);
-            let removeInlineAfter = false;
-            if (toValue === 'initial' ||
-                toValue === 'inherit' ||
-                toValue === 'unset' ||
-                toValue === 'revert') {
-                const currentInline = targetElement.style.getPropertyValue(property);
-                targetElement.style.removeProperty(property);
-                toValue = getComputedStyle(targetElement).getPropertyValue(property);
-                if (currentInline) {
-                    targetElement.style.setProperty(property, currentInline);
-                }
-                removeInlineAfter = true;
-            }
-            targetElement.style.setProperty(property, toValue);
-            const result = await waitForTransitionEnd(targetElement, property, duration);
-            targetElement.style.transition = originalTransition;
-            if (removeInlineAfter) {
-                targetElement.style.removeProperty(property);
+            const duration = parseDuration(input.duration, (input.using !== undefined && longestTransitionMs(input.using)) || 300);
+            const timing = input.timingFunction || 'ease';
+            const jobs = [];
+            for (const pair of [input, ...(input.pairs ?? [])]) {
+                let property = pair.property;
+                if (property.startsWith('*'))
+                    property = property.substring(1);
+                property = camelToKebab(property);
+                const elements = Array.isArray(pair.target)
+                    ? pair.target.filter(isHTMLElement$2)
+                    : [resolveElement(pair.target, context, 'transition')];
+                for (const element of elements) {
+                    jobs.push({
+                        element,
+                        property,
+                        pair,
+                        fromValue: getComputedStyle(element).getPropertyValue(property),
+                        toValue: '',
+                        removeInlineAfter: false,
+                    });
+                }
+            }
+            if (jobs.length === 0)
+                throw new Error('transition: target element not found');
+            for (const job of jobs) {
+                if (job.pair.from !== undefined) {
+                    job.element.style.setProperty(job.property, String(job.pair.from));
+                }
+            }
+            for (const job of jobs)
+                if (job.pair.from !== undefined)
+                    void job.element.offsetWidth;
+            const originals = new Map();
+            for (const job of jobs) {
+                if (!originals.has(job.element))
+                    originals.set(job.element, job.element.style.transition);
+            }
+            for (const [element, original] of originals) {
+                const own = jobs
+                    .filter(job => job.element === element)
+                    .map(job => `${job.property} ${duration}ms ${timing}`);
+                element.style.transition = input.using ?? [original, ...own].filter(Boolean).join(', ');
+            }
+            for (const job of jobs) {
+                const { element, property } = job;
+                let toValue = String(job.pair.value);
+                if (RESTORE_KEYWORDS.has(toValue)) {
+                    const currentInline = element.style.getPropertyValue(property);
+                    element.style.removeProperty(property);
+                    toValue = getComputedStyle(element).getPropertyValue(property);
+                    if (currentInline) {
+                        element.style.setProperty(property, currentInline);
+                    }
+                    job.removeInlineAfter = true;
+                }
+                job.toValue = toValue;
+                element.style.setProperty(property, toValue);
+            }
+            const results = await Promise.all(jobs.map(job => waitForTransitionEnd(job.element, job.property, duration)));
+            for (const [element, original] of originals)
+                element.style.transition = original;
+            for (const job of jobs) {
+                if (job.removeInlineAfter)
+                    job.element.style.removeProperty(job.property);
             }
+            const first = jobs[0];
             return {
-                element: targetElement,
-                property,
-                fromValue,
-                toValue,
+                element: first.element,
+                property: first.property,
+                fromValue: first.fromValue,
+                toValue: first.toValue,
                 duration,
-                completed: result.completed,
+                completed: results.every(result => result.completed),
             };
         }
     };
@@ -23855,13 +24451,16 @@ let TransitionCommand = (() => {
     })();
     _classThis.metadata = commandMeta({
         description: 'Animate CSS properties using CSS transitions',
-        syntax: 'transition [<target>] <property> to <value> [over <duration>] [with <timing>]',
+        syntax: 'transition <property> [from <value>] to <value> [<property> \u2026 to <value>]\u2026 [over <duration>] [using <css> | with <timing>]',
         examples: [
             'transition opacity to 0.5',
             'transition my *opacity to 0 over 200ms',
             "transition #box's *opacity to 0 over 200ms",
             'transition left to 100px over 500ms',
             'transition background-color to red over 1s with ease-in-out',
+            'transition *width to 100px *height to 50px over 300ms',
+            'transition *opacity of #panel from 0 to 1 over 200ms',
+            'transition my *opacity to 0 using "opacity 1s ease-in"',
         ],
         sideEffects: ['style-change', 'timing'],
         category: 'animation',
@@ -25111,17 +25710,7 @@ let BeepCommand = (() => {
                 this.debugContext(context);
                 return { expressionCount: 0, debugged: true, outputs: [] };
             }
-            const outputs = [];
-            console.group('\ud83d\udd14 beep! Debug Output');
-            for (const expression of expressions) {
-                const output = this.debugExpression(expression);
-                outputs.push(output);
-                console.log(`Value:`, expression);
-                console.log(`Type:`, output.type);
-                console.log(`Representation:`, output.representation);
-                console.log('---');
-            }
-            console.groupEnd();
+            const outputs = beepValues(context.me, expressions);
             return { expressionCount: expressions.length, debugged: true, outputs };
         }
         debugContext(context) {
@@ -25134,67 +25723,6 @@ let BeepCommand = (() => {
             console.log('variables:', context.variables);
             console.groupEnd();
         }
-        debugExpression(expression) {
-            return {
-                value: expression,
-                type: this.getType(expression),
-                representation: this.getRepresentation(expression),
-            };
-        }
-        getType(value) {
-            if (value === null)
-                return 'null';
-            if (value === undefined)
-                return 'undefined';
-            if (Array.isArray(value))
-                return 'array';
-            if (isHTMLElement$2(value))
-                return 'HTMLElement';
-            if (value instanceof Element)
-                return 'Element';
-            if (value instanceof Node)
-                return 'Node';
-            if (value instanceof Error)
-                return 'Error';
-            if (value instanceof Date)
-                return 'Date';
-            if (value instanceof RegExp)
-                return 'RegExp';
-            return typeof value;
-        }
-        getRepresentation(value) {
-            if (value === null)
-                return 'null';
-            if (value === undefined)
-                return 'undefined';
-            if (Array.isArray(value)) {
-                return `Array(${value.length}) [${value
-                    .slice(0, 3)
-                    .map(v => this.getRepresentation(v))
-                    .join(', ')}${value.length > 3 ? '...' : ''}]`;
-            }
-            if (isHTMLElement$2(value)) {
-                const el = value;
-                const tag = el.tagName.toLowerCase();
-                const id = el.id ? `#${el.id}` : '';
-                const classes = el.className ? `.${el.className.split(' ').join('.')}` : '';
-                return `<${tag}${id}${classes}/>`;
-            }
-            if (value instanceof Error)
-                return `Error: ${value.message}`;
-            if (typeof value === 'string')
-                return value.length > 50 ? `"${value.substring(0, 47)}..."` : `"${value}"`;
-            if (typeof value === 'object') {
-                try {
-                    const keys = Object.keys(value);
-                    return `Object {${keys.slice(0, 3).join(', ')}${keys.length > 3 ? '...' : ''}}`;
-                }
-                catch {
-                    return '[Object]';
-                }
-            }
-            return String(value);
-        }
     };
     __setFunctionName(_classThis, "BeepCommand");
     (() => {
@@ -25742,16 +26270,12 @@ class RenderCommand {
 }
 RenderCommand.metadata = commandMeta({
     description: 'Render templates with @if, @else, and @repeat directives',
-    syntax: [
-        'render <template>',
-        'render <template> with <variables>',
-        'render <template> with (key: value, ...)',
-    ],
+    syntax: ['render <template>', 'render <template> with <name>: <value>, ...'],
     examples: [
         'render myTemplate',
-        'render myTemplate with (name: "Alice")',
-        'render "<template>Hello ${name}!</template>" with (name: "World")',
-        'render template with (items: data)',
+        'render myTemplate with name: "Alice"',
+        'render "<template>Hello ${name}!</template>" with name: "World"',
+        'render template with items: data',
     ],
     category: 'templates',
     compatibility: 'standard',
@@ -25939,7 +26463,7 @@ function updateDebugStats(event) {
         stats.confidenceHistory.reduce((a, b) => a + b, 0) / stats.confidenceHistory.length;
 }
 
-const VERSION = '3.1.1';
+const VERSION = '3.3.0';
 
 function createHistorySwap(config) {
     const { target, strategy = 'morph', useViewTransition = false, fetchOptions = {}, transformUrl, onBeforeFetch, onAfterSwap, onError, } = config;
@@ -27485,6 +28009,14 @@ function convertNode(node, infer) {
                 ...pos(node),
             };
         case 'identifier':
+            if (node.scope === 'element' || node.scope === 'local' || node.scope === 'global') {
+                return {
+                    type: 'variable',
+                    name: (node.name ?? ''),
+                    scope: node.scope,
+                    ...pos(node),
+                };
+            }
             return {
                 type: 'identifier',
                 value: (node.name ?? node.value ?? ''),
@@ -27507,6 +28039,15 @@ function convertNode(node, infer) {
                 operand: convertNode(node.argument ?? node.operand, infer),
                 ...pos(node),
             };
+        case 'typeCheckExpression':
+            return {
+                type: 'typeCheck',
+                value: convertNode(node.value, infer),
+                typeName: String(node.typeName),
+                nullOk: node.nullOk !== false,
+                negated: node.negated === true,
+                ...pos(node),
+            };
         case 'timeExpression':
             return { type: 'literal', value: node.value, ...pos(node) };
         case 'templateLiteral':
@@ -27518,6 +28059,28 @@ function convertNode(node, infer) {
                 scope: (node.scope ?? 'local'),
                 ...pos(node),
             };
+        case 'arrayLiteral':
+            return {
+                type: 'array',
+                elements: (node.elements ?? []).map(element => convertNode(element, infer)),
+                ...pos(node),
+            };
+        case 'attributeAccess':
+            return {
+                type: 'possessive',
+                object: { type: 'identifier', value: 'me' },
+                property: `@${node.attributeName}`,
+                ...pos(node),
+            };
+        case 'propertyOfExpression': {
+            const property = node.property;
+            return {
+                type: 'possessive',
+                object: convertNode(node.target, infer),
+                property: (property?.name ?? property?.value ?? ''),
+                ...pos(node),
+            };
+        }
         case 'htmlSelector':
             return {
                 type: 'selector',
@@ -27569,6 +28132,21 @@ function convertCommand$1(node, infer) {
     if (name === 'repeat') {
         return convertRepeatCommand(node, infer);
     }
+    const original = node.originalCommand;
+    const sum = node.modifiers?.to;
+    const counted = node.args?.[0];
+    if (name === 'set' &&
+        (original === 'increment' || original === 'decrement') &&
+        sum?.type === 'binaryExpression' &&
+        counted) {
+        return convertCommand$1({
+            ...node,
+            name: original,
+            args: [counted],
+            modifiers: { by: sum.right },
+            originalCommand: undefined,
+        }, infer);
+    }
     const args = (node.args ?? []).map(arg => convertNode(arg, infer));
     const target = node.target ? convertNode(node.target, infer) : undefined;
     const modifiers = node.modifiers
@@ -27617,6 +28195,64 @@ function convertIfCommand(node, infer) {
     };
 }
 function convertRepeatCommand(node, infer) {
+    const slots = (node.modifiers ?? {});
+    const form = slotText(slots.loopType);
+    if (form === undefined)
+        return convertPositionalRepeat(node, infer);
+    const [bodyBlock, elseBlock] = (node.args ?? []);
+    const body = extractBlockCommands(bodyBlock, infer);
+    const indexName = slotText(slots.index);
+    const shared = {
+        ...(indexName ? { indexName } : {}),
+        ...(elseBlock ? { elseBody: extractBlockCommands(elseBlock, infer) } : {}),
+        ...pos(node),
+    };
+    const operand = (slot) => (slot ? convertNode(slot, infer) : undefined);
+    switch (form) {
+        case 'for':
+            return {
+                type: 'foreach',
+                itemName: slotText(slots.for) ?? 'it',
+                collection: operand(slots.in) ?? { type: 'literal', value: null },
+                body,
+                ...shared,
+            };
+        case 'times':
+            return { type: 'repeat', count: operand(slots.times), body, ...shared };
+        case 'while':
+        case 'until': {
+            const test = operand(slots[form]) ?? { type: 'literal', value: form === 'until' };
+            return {
+                type: 'while',
+                condition: form === 'until' ? { type: 'unary', operator: 'not', operand: test } : test,
+                ...(slots.bottomTested?.value === true ? { bottomTested: true } : {}),
+                body,
+                ...shared,
+            };
+        }
+        case 'until-event': {
+            const event = slotText(slots.event);
+            if (!event) {
+                return { type: 'error', message: "'repeat until event' has no event name", ...pos(node) };
+            }
+            const target = operand(slots.from);
+            return {
+                type: 'repeat',
+                untilEvent: event,
+                ...(target ? { untilEventTarget: target } : {}),
+                body,
+                ...shared,
+            };
+        }
+        default:
+            return { type: 'repeat', body, ...shared };
+    }
+}
+function slotText(slot) {
+    const text = slot?.value ?? slot?.name;
+    return typeof text === 'string' ? text : undefined;
+}
+function convertPositionalRepeat(node, infer) {
     const args = (node.args ?? []);
     if (args.length === 0) {
         return { type: 'repeat', body: [], ...pos(node) };
@@ -27933,6 +28569,15 @@ function toCoreAST(node) {
                 prefix: true,
                 ...nodePos(node),
             };
+        case 'typeCheck':
+            return {
+                type: 'typeCheckExpression',
+                value: toCoreAST(node.value),
+                typeName: node.typeName,
+                nullOk: node.nullOk,
+                negated: node.negated,
+                ...nodePos(node),
+            };
         case 'member':
             return {
                 type: 'memberExpression',
@@ -27943,6 +28588,12 @@ function toCoreAST(node) {
                 computed: node.computed ?? false,
                 ...nodePos(node),
             };
+        case 'array':
+            return {
+                type: 'arrayLiteral',
+                elements: node.elements.map(element => toCoreAST(element)),
+                ...nodePos(node),
+            };
         case 'possessive':
             return {
                 type: 'possessiveExpression',
@@ -28005,72 +28656,85 @@ function convertCommand(node) {
     }
     return result;
 }
+function block(nodes) {
+    return { type: 'block', commands: nodes.map(n => toCoreAST(n)), ...POS };
+}
 function convertIf(node) {
-    const result = {
+    const [elseIf, ...laterElseIfs] = node.elseIfBranches ?? [];
+    const elseBranch = elseIf
+        ? [
+            {
+                type: 'if',
+                condition: elseIf.condition,
+                thenBranch: elseIf.body,
+                elseIfBranches: laterElseIfs,
+                ...(node.elseBranch ? { elseBranch: node.elseBranch } : {}),
+            },
+        ]
+        : node.elseBranch;
+    return {
         type: 'command',
         name: 'if',
         isBlocking: true,
-        condition: toCoreAST(node.condition),
-        thenBranch: node.thenBranch.map(n => toCoreAST(n)),
-        args: [],
+        args: [
+            toCoreAST(node.condition),
+            block(node.thenBranch),
+            ...(elseBranch ? [block(elseBranch)] : []),
+        ],
         ...nodePos(node),
     };
-    if (node.elseBranch) {
-        result.elseBranch = node.elseBranch.map(n => toCoreAST(n));
-    }
-    return result;
 }
-function convertRepeat(node) {
-    const result = {
+function loopCommand(node, form, operands) {
+    const modifiers = { loopType: slotString(form) };
+    for (const [slot, value] of Object.entries(operands)) {
+        if (value)
+            modifiers[slot] = value;
+    }
+    if (node.indexName)
+        modifiers.index = slotString(node.indexName);
+    return {
         type: 'command',
         name: 'repeat',
         isBlocking: true,
-        body: node.body.map(n => toCoreAST(n)),
-        args: [],
+        args: [block(node.body), ...(node.elseBody ? [block(node.elseBody)] : [])],
+        modifiers,
         ...nodePos(node),
     };
+}
+function slotString(value) {
+    return { type: 'string', value, ...POS };
+}
+function convertRepeat(node) {
     if (node.count !== undefined) {
-        result.count =
-            typeof node.count === 'number'
-                ? { type: 'literal', value: node.count, raw: String(node.count), ...POS }
-                : toCoreAST(node.count);
-        result.loopVariant = 'times';
-    }
-    else if (node.whileCondition !== undefined) {
-        result.condition = toCoreAST(node.whileCondition);
-        result.loopVariant = 'while';
-    }
-    else if (node.untilEvent !== undefined) {
-        result.untilEvent = node.untilEvent;
-        result.loopVariant = 'until';
+        const times = typeof node.count === 'number'
+            ? { type: 'literal', value: node.count, raw: String(node.count), ...POS }
+            : toCoreAST(node.count);
+        return loopCommand(node, 'times', { times });
+    }
+    if (node.whileCondition !== undefined) {
+        return loopCommand(node, 'while', { while: toCoreAST(node.whileCondition) });
+    }
+    if (node.untilEvent !== undefined) {
+        return loopCommand(node, 'until-event', {
+            event: slotString(node.untilEvent),
+            from: node.untilEventTarget ? toCoreAST(node.untilEventTarget) : undefined,
+        });
     }
-    return result;
+    return loopCommand(node, 'forever', {});
 }
 function convertForEach(node) {
-    return {
-        type: 'command',
-        name: 'repeat',
-        isBlocking: true,
-        loopVariant: 'for',
-        itemName: node.itemName,
-        ...(node.indexName ? { indexName: node.indexName } : {}),
-        collection: toCoreAST(node.collection),
-        body: node.body.map(n => toCoreAST(n)),
-        args: [],
-        ...nodePos(node),
-    };
+    return loopCommand(node, 'for', {
+        for: slotString(node.itemName),
+        in: toCoreAST(node.collection),
+    });
 }
 function convertWhile(node) {
-    return {
-        type: 'command',
-        name: 'repeat',
-        isBlocking: true,
-        loopVariant: 'while',
-        condition: toCoreAST(node.condition),
-        body: node.body.map(n => toCoreAST(n)),
-        args: [],
-        ...nodePos(node),
-    };
+    return loopCommand(node, 'while', {
+        while: toCoreAST(node.condition),
+        bottomTested: node.bottomTested
+            ? { type: 'literal', value: true, raw: 'true', ...POS }
+            : undefined,
+    });
 }
 function flattenEventModifiers(modifiers) {
     if (!modifiers)