@hyperfixi/core 2.6.0 → 2.7.0

package/dist/parser/full-parser.js

@@ -4007,7 +4007,7 @@ function parseColonVariable(ctx) {
     return {
         type: 'identifier',
         name: varToken.value,
-        scope: 'local',
+        scope: 'element',
         start: varToken.start - 1,
         end: varToken.end,
     };
@@ -4059,7 +4059,7 @@ function parseTargetFallback(ctx) {
             expression: {
                 type: 'identifier',
                 name: varToken.value,
-                scope: 'local',
+                scope: 'element',
                 start: varToken.start,
                 end: varToken.end,
             },
@@ -4140,6 +4140,11 @@ function parseSetCommand(ctx, identifierNode) {
     }
     ctx.advance();
     const value = ctx.parseExpression() ?? ctx.parsePrimary();
+    let scopeTarget;
+    if (ctx.check(KEYWORDS.ON) && tokenLooksLikeElementTarget(ctx.peekAt(1))) {
+        ctx.advance();
+        scopeTarget = parseOneArgument(ctx);
+    }
     const finalArgs = [];
     if (targetExpression) {
         finalArgs.push(targetExpression);
@@ -4151,11 +4156,22 @@ function parseSetCommand(ctx, identifierNode) {
     if (value) {
         finalArgs.push(value);
     }
-    return CommandNodeBuilder.fromIdentifier(identifierNode)
-        .withArgs(...finalArgs)
-        .endingAt(ctx.getPosition())
-        .build();
+    const builder = CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...finalArgs);
+    if (scopeTarget) {
+        builder.withModifier('on', scopeTarget);
+    }
+    return builder.endingAt(ctx.getPosition()).build();
 }
+function tokenLooksLikeElementTarget(token) {
+    if (!token)
+        return false;
+    if (token.kind === 'selector')
+        return true;
+    if (token.value.startsWith('<'))
+        return true;
+    return ELEMENT_PRONOUNS.has(token.value);
+}
+const ELEMENT_PRONOUNS = new Set(['me', 'my', 'it', 'its', 'you', 'your', 'yourself']);
 function parseIncrementDecrementCommand(ctx, commandToken) {
     const commandName = commandToken.value;
     const isIncrement = commandName === 'increment';
@@ -4201,6 +4217,7 @@ function parseIncrementDecrementCommand(ctx, commandToken) {
         column: commandToken.column,
     };
     const binaryExpr = createBinaryExpression(operator, target, amount, pos);
+    binaryExpr.coerceNumeric = true;
     const toIdentifier = createIdentifier(KEYWORDS.TO, pos);
     const args = [targetWithScope, toIdentifier, binaryExpr];
     return CommandNodeBuilder.from(commandToken)
@@ -4819,6 +4836,18 @@ class Parser {
                         this.advance();
                         continue;
                     }
+                    if (this.check('then')) {
+                        const next = this.peekAt(1);
+                        const startsFeature = next !== null &&
+                            (next.value === 'init' ||
+                                next.value === 'on' ||
+                                next.value === 'def' ||
+                                getRegisteredFeature(next.value) !== undefined);
+                        if (startsFeature) {
+                            this.advance();
+                            continue;
+                        }
+                    }
                     if (this.check('init')) {
                         this.advance();
                         const initBlock = this.parseTopLevelInitBlock();
@@ -5619,7 +5648,7 @@ class Parser {
                 return {
                     type: 'identifier',
                     name: varToken.value,
-                    scope: 'local',
+                    scope: 'element',
                     start: varToken.start - 1,
                     end: varToken.end,
                     line: varToken.line,
@@ -6246,6 +6275,33 @@ class Parser {
             return null;
         }
     }
+    parseTemporalKeywordModifiers(modifiers) {
+        if (!this.check('debounced') && !this.check('throttled')) {
+            return;
+        }
+        const modToken = this.advance();
+        const modName = modToken.value.toLowerCase();
+        const modifierKey = modName === 'debounced' ? 'debounce' : 'throttle';
+        if (this.match('at')) {
+            if (this.checkTimeExpression()) {
+                const timeToken = this.advance();
+                const delayMs = parseTimeToMs(timeToken.value);
+                modifiers[modifierKey] = delayMs;
+                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
+            }
+            else if (this.matchNumber()) {
+                const delayMs = parseInt(this.previous().value, 10);
+                modifiers[modifierKey] = delayMs;
+                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
+            }
+            else {
+                this.addError(`Expected time expression after '${modName} at', got: ${this.peek().value}`);
+            }
+        }
+        else {
+            this.addError(`Expected 'at' after '${modName}'`);
+        }
+    }
     parseEventHandler() {
         debug.parse(`🔧 parseEventHandler: ENTRY - parsing event handler`);
         const eventNames = [];
@@ -6333,30 +6389,7 @@ class Parser {
                 debug.parse(`🔧 parseEventHandler: Warning - unknown modifier '.${modName}'`);
             }
         }
-        if (this.check('debounced') || this.check('throttled')) {
-            const modToken = this.advance();
-            const modName = modToken.value.toLowerCase();
-            const modifierKey = modName === 'debounced' ? 'debounce' : 'throttle';
-            if (this.match('at')) {
-                if (this.checkTimeExpression()) {
-                    const timeToken = this.advance();
-                    const delayMs = parseTimeToMs(timeToken.value);
-                    modifiers[modifierKey] = delayMs;
-                    debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
-                }
-                else if (this.matchNumber()) {
-                    const delayMs = parseInt(this.previous().value, 10);
-                    modifiers[modifierKey] = delayMs;
-                    debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
-                }
-                else {
-                    this.addError(`Expected time expression after '${modName} at', got: ${this.peek().value}`);
-                }
-            }
-            else {
-                this.addError(`Expected 'at' after '${modName}'`);
-            }
-        }
+        this.parseTemporalKeywordModifiers(modifiers);
         if (firstOnceAlias) {
             modifiers.once = true;
         }
@@ -6373,6 +6406,7 @@ class Parser {
             const targetToken = this.advance();
             target = targetToken.value;
             debug.parse(`🔧 parseEventHandler: Parsed 'from' target: ${target} (kind: ${targetToken.kind})`);
+            this.parseTemporalKeywordModifiers(modifiers);
         }
         let attributeName;
         if (this.match('of')) {
@@ -7343,6 +7377,10 @@ class Parser {
         }
         return this.tokens[this.current];
     }
+    peekAt(offset) {
+        const index = this.current + offset;
+        return index >= 0 && index < this.tokens.length ? this.tokens[index] : null;
+    }
     previous() {
         return this.tokens[this.current - 1];
     }
@@ -7547,10 +7585,7 @@ class Parser {
             restorePosition: (pos) => {
                 parser.current = pos;
             },
-            peekAt: (offset) => {
-                const index = parser.current + offset;
-                return index >= 0 && index < parser.tokens.length ? parser.tokens[index] : null;
-            },
+            peekAt: (offset) => parser.peekAt(offset),
             getInputSlice: (start, end) => {
                 if (!this.originalInput)
                     return '';

package/dist/parser/full-parser.mjs

@@ -4005,7 +4005,7 @@ function parseColonVariable(ctx) {
     return {
         type: 'identifier',
         name: varToken.value,
-        scope: 'local',
+        scope: 'element',
         start: varToken.start - 1,
         end: varToken.end,
     };
@@ -4057,7 +4057,7 @@ function parseTargetFallback(ctx) {
             expression: {
                 type: 'identifier',
                 name: varToken.value,
-                scope: 'local',
+                scope: 'element',
                 start: varToken.start,
                 end: varToken.end,
             },
@@ -4138,6 +4138,11 @@ function parseSetCommand(ctx, identifierNode) {
     }
     ctx.advance();
     const value = ctx.parseExpression() ?? ctx.parsePrimary();
+    let scopeTarget;
+    if (ctx.check(KEYWORDS.ON) && tokenLooksLikeElementTarget(ctx.peekAt(1))) {
+        ctx.advance();
+        scopeTarget = parseOneArgument(ctx);
+    }
     const finalArgs = [];
     if (targetExpression) {
         finalArgs.push(targetExpression);
@@ -4149,11 +4154,22 @@ function parseSetCommand(ctx, identifierNode) {
     if (value) {
         finalArgs.push(value);
     }
-    return CommandNodeBuilder.fromIdentifier(identifierNode)
-        .withArgs(...finalArgs)
-        .endingAt(ctx.getPosition())
-        .build();
+    const builder = CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...finalArgs);
+    if (scopeTarget) {
+        builder.withModifier('on', scopeTarget);
+    }
+    return builder.endingAt(ctx.getPosition()).build();
 }
+function tokenLooksLikeElementTarget(token) {
+    if (!token)
+        return false;
+    if (token.kind === 'selector')
+        return true;
+    if (token.value.startsWith('<'))
+        return true;
+    return ELEMENT_PRONOUNS.has(token.value);
+}
+const ELEMENT_PRONOUNS = new Set(['me', 'my', 'it', 'its', 'you', 'your', 'yourself']);
 function parseIncrementDecrementCommand(ctx, commandToken) {
     const commandName = commandToken.value;
     const isIncrement = commandName === 'increment';
@@ -4199,6 +4215,7 @@ function parseIncrementDecrementCommand(ctx, commandToken) {
         column: commandToken.column,
     };
     const binaryExpr = createBinaryExpression(operator, target, amount, pos);
+    binaryExpr.coerceNumeric = true;
     const toIdentifier = createIdentifier(KEYWORDS.TO, pos);
     const args = [targetWithScope, toIdentifier, binaryExpr];
     return CommandNodeBuilder.from(commandToken)
@@ -4817,6 +4834,18 @@ class Parser {
                         this.advance();
                         continue;
                     }
+                    if (this.check('then')) {
+                        const next = this.peekAt(1);
+                        const startsFeature = next !== null &&
+                            (next.value === 'init' ||
+                                next.value === 'on' ||
+                                next.value === 'def' ||
+                                getRegisteredFeature(next.value) !== undefined);
+                        if (startsFeature) {
+                            this.advance();
+                            continue;
+                        }
+                    }
                     if (this.check('init')) {
                         this.advance();
                         const initBlock = this.parseTopLevelInitBlock();
@@ -5617,7 +5646,7 @@ class Parser {
                 return {
                     type: 'identifier',
                     name: varToken.value,
-                    scope: 'local',
+                    scope: 'element',
                     start: varToken.start - 1,
                     end: varToken.end,
                     line: varToken.line,
@@ -6244,6 +6273,33 @@ class Parser {
             return null;
         }
     }
+    parseTemporalKeywordModifiers(modifiers) {
+        if (!this.check('debounced') && !this.check('throttled')) {
+            return;
+        }
+        const modToken = this.advance();
+        const modName = modToken.value.toLowerCase();
+        const modifierKey = modName === 'debounced' ? 'debounce' : 'throttle';
+        if (this.match('at')) {
+            if (this.checkTimeExpression()) {
+                const timeToken = this.advance();
+                const delayMs = parseTimeToMs(timeToken.value);
+                modifiers[modifierKey] = delayMs;
+                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
+            }
+            else if (this.matchNumber()) {
+                const delayMs = parseInt(this.previous().value, 10);
+                modifiers[modifierKey] = delayMs;
+                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
+            }
+            else {
+                this.addError(`Expected time expression after '${modName} at', got: ${this.peek().value}`);
+            }
+        }
+        else {
+            this.addError(`Expected 'at' after '${modName}'`);
+        }
+    }
     parseEventHandler() {
         debug.parse(`🔧 parseEventHandler: ENTRY - parsing event handler`);
         const eventNames = [];
@@ -6331,30 +6387,7 @@ class Parser {
                 debug.parse(`🔧 parseEventHandler: Warning - unknown modifier '.${modName}'`);
             }
         }
-        if (this.check('debounced') || this.check('throttled')) {
-            const modToken = this.advance();
-            const modName = modToken.value.toLowerCase();
-            const modifierKey = modName === 'debounced' ? 'debounce' : 'throttle';
-            if (this.match('at')) {
-                if (this.checkTimeExpression()) {
-                    const timeToken = this.advance();
-                    const delayMs = parseTimeToMs(timeToken.value);
-                    modifiers[modifierKey] = delayMs;
-                    debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
-                }
-                else if (this.matchNumber()) {
-                    const delayMs = parseInt(this.previous().value, 10);
-                    modifiers[modifierKey] = delayMs;
-                    debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
-                }
-                else {
-                    this.addError(`Expected time expression after '${modName} at', got: ${this.peek().value}`);
-                }
-            }
-            else {
-                this.addError(`Expected 'at' after '${modName}'`);
-            }
-        }
+        this.parseTemporalKeywordModifiers(modifiers);
         if (firstOnceAlias) {
             modifiers.once = true;
         }
@@ -6371,6 +6404,7 @@ class Parser {
             const targetToken = this.advance();
             target = targetToken.value;
             debug.parse(`🔧 parseEventHandler: Parsed 'from' target: ${target} (kind: ${targetToken.kind})`);
+            this.parseTemporalKeywordModifiers(modifiers);
         }
         let attributeName;
         if (this.match('of')) {
@@ -7341,6 +7375,10 @@ class Parser {
         }
         return this.tokens[this.current];
     }
+    peekAt(offset) {
+        const index = this.current + offset;
+        return index >= 0 && index < this.tokens.length ? this.tokens[index] : null;
+    }
     previous() {
         return this.tokens[this.current - 1];
     }
@@ -7545,10 +7583,7 @@ class Parser {
             restorePosition: (pos) => {
                 parser.current = pos;
             },
-            peekAt: (offset) => {
-                const index = parser.current + offset;
-                return index >= 0 && index < parser.tokens.length ? parser.tokens[index] : null;
-            },
+            peekAt: (offset) => parser.peekAt(offset),
             getInputSlice: (start, end) => {
                 if (!this.originalInput)
                     return '';

package/dist/parser/parser-types.d.ts

@@ -8,7 +8,7 @@ export interface Position {
 export interface IdentifierNode extends ASTNode {
     type: 'identifier';
     name: string;
-    scope?: 'local' | 'global';
+    scope?: 'local' | 'element' | 'global';
 }
 export interface LiteralNode extends ASTNode {
     type: 'literal';

package/dist/parser/parser.d.ts

@@ -67,6 +67,7 @@ export declare class Parser {
     private createPseudoCommandNode;
     private tryParsePseudoCommand;
     private parseCommandWithErrorRecovery;
+    private parseTemporalKeywordModifiers;
     private parseEventHandler;
     private parseBehaviorDefinition;
     private parseCommandSequence;
@@ -143,6 +144,7 @@ export declare class Parser {
     private advance;
     private isAtEnd;
     private peek;
+    private peekAt;
     private previous;
     private consume;
     private addError;

package/dist/parser/regex-parser.js

@@ -95,6 +95,15 @@ function parseCommand(code) {
     }
     return null;
 }
+const elementVars = new WeakMap();
+function elemScope(el) {
+    let m = elementVars.get(el);
+    if (!m) {
+        m = new Map();
+        elementVars.set(el, m);
+    }
+    return m;
+}
 function resolveTarget(target, me) {
     if (!target)
         return me;
@@ -148,7 +157,7 @@ async function executeCommand(cmd, me, locals) {
             return null;
         }
         case 'put': {
-            const content = evaluateValue(cmd.args[0], me, locals);
+            const content = evaluateValue(cmd.args[0], me);
             for (const el of elements) {
                 switch (cmd.modifier?.toLowerCase()) {
                     case 'into':
@@ -168,9 +177,9 @@ async function executeCommand(cmd, me, locals) {
         }
         case 'set': {
             const [targetExpr, valueExpr] = cmd.args;
-            const value = evaluateValue(valueExpr, me, locals);
+            const value = evaluateValue(valueExpr, me);
             if (targetExpr.startsWith(':')) {
-                locals.set(targetExpr.slice(1), value);
+                elemScope(me).set(targetExpr.slice(1), value);
                 return value;
             }
             const propMatch = targetExpr.match(/^(.+?)(?:'s|\.)\s*(\w+)$/);
@@ -184,7 +193,7 @@ async function executeCommand(cmd, me, locals) {
             return value;
         }
         case 'log': {
-            const value = evaluateValue(cmd.args.join(' '), me, locals);
+            const value = evaluateValue(cmd.args.join(' '), me);
             console.log(value);
             return value;
         }
@@ -223,7 +232,7 @@ function evaluateValue(expr, me, locals) {
     if (e === 'null')
         return null;
     if (e.startsWith(':')) {
-        return locals.get(e.slice(1));
+        return elemScope(me).get(e.slice(1));
     }
     if (e === 'me')
         return me;
@@ -242,13 +251,13 @@ async function executeParsed(parsed, me, locals = new Map()) {
         let result;
         for (const cmd of parsed) {
             if (cmd.modifier === 'if' || cmd.modifier === 'unless') {
-                const condition = evaluateCondition(cmd.args[0], me, locals);
+                const condition = evaluateCondition(cmd.args[0], me);
                 const shouldRun = cmd.modifier === 'if' ? condition : !condition;
                 if (!shouldRun)
                     continue;
                 cmd.args.shift();
             }
-            result = await executeCommand(cmd, me, locals);
+            result = await executeCommand(cmd, me);
         }
         return result;
     }
@@ -258,17 +267,17 @@ async function executeParsed(parsed, me, locals = new Map()) {
     if (eventName.startsWith('interval:')) {
         const ms = parseInt(eventName.split(':')[1]);
         setInterval(async () => {
-            const handlerLocals = new Map(locals);
+            new Map(locals);
             for (const cmd of handler.commands) {
-                await executeCommand(cmd, me, handlerLocals);
+                await executeCommand(cmd, me);
             }
         }, ms);
         return me;
     }
     if (eventName === 'init') {
-        const handlerLocals = new Map(locals);
+        new Map(locals);
         for (const cmd of handler.commands) {
-            await executeCommand(cmd, me, handlerLocals);
+            await executeCommand(cmd, me);
         }
         return me;
     }
@@ -277,7 +286,7 @@ async function executeParsed(parsed, me, locals = new Map()) {
             const handlerLocals = new Map(locals);
             handlerLocals.set('event', event);
             for (const cmd of handler.commands) {
-                await executeCommand(cmd, me, handlerLocals);
+                await executeCommand(cmd, me);
             }
         });
     }
@@ -294,9 +303,9 @@ function evaluateCondition(expr, me, locals) {
         return Boolean(me[propMatch[2]]);
     }
     if (e.startsWith(':')) {
-        return Boolean(locals.get(e.slice(1)));
+        return Boolean(elemScope(me).get(e.slice(1)));
     }
-    const value = evaluateValue(e, me, locals);
+    const value = evaluateValue(e, me);
     return Boolean(value);
 }
 function processElements(root = document) {

package/dist/parser/regex-parser.mjs

@@ -93,6 +93,15 @@ function parseCommand(code) {
     }
     return null;
 }
+const elementVars = new WeakMap();
+function elemScope(el) {
+    let m = elementVars.get(el);
+    if (!m) {
+        m = new Map();
+        elementVars.set(el, m);
+    }
+    return m;
+}
 function resolveTarget(target, me) {
     if (!target)
         return me;
@@ -146,7 +155,7 @@ async function executeCommand(cmd, me, locals) {
             return null;
         }
         case 'put': {
-            const content = evaluateValue(cmd.args[0], me, locals);
+            const content = evaluateValue(cmd.args[0], me);
             for (const el of elements) {
                 switch (cmd.modifier?.toLowerCase()) {
                     case 'into':
@@ -166,9 +175,9 @@ async function executeCommand(cmd, me, locals) {
         }
         case 'set': {
             const [targetExpr, valueExpr] = cmd.args;
-            const value = evaluateValue(valueExpr, me, locals);
+            const value = evaluateValue(valueExpr, me);
             if (targetExpr.startsWith(':')) {
-                locals.set(targetExpr.slice(1), value);
+                elemScope(me).set(targetExpr.slice(1), value);
                 return value;
             }
             const propMatch = targetExpr.match(/^(.+?)(?:'s|\.)\s*(\w+)$/);
@@ -182,7 +191,7 @@ async function executeCommand(cmd, me, locals) {
             return value;
         }
         case 'log': {
-            const value = evaluateValue(cmd.args.join(' '), me, locals);
+            const value = evaluateValue(cmd.args.join(' '), me);
             console.log(value);
             return value;
         }
@@ -221,7 +230,7 @@ function evaluateValue(expr, me, locals) {
     if (e === 'null')
         return null;
     if (e.startsWith(':')) {
-        return locals.get(e.slice(1));
+        return elemScope(me).get(e.slice(1));
     }
     if (e === 'me')
         return me;
@@ -240,13 +249,13 @@ async function executeParsed(parsed, me, locals = new Map()) {
         let result;
         for (const cmd of parsed) {
             if (cmd.modifier === 'if' || cmd.modifier === 'unless') {
-                const condition = evaluateCondition(cmd.args[0], me, locals);
+                const condition = evaluateCondition(cmd.args[0], me);
                 const shouldRun = cmd.modifier === 'if' ? condition : !condition;
                 if (!shouldRun)
                     continue;
                 cmd.args.shift();
             }
-            result = await executeCommand(cmd, me, locals);
+            result = await executeCommand(cmd, me);
         }
         return result;
     }
@@ -256,17 +265,17 @@ async function executeParsed(parsed, me, locals = new Map()) {
     if (eventName.startsWith('interval:')) {
         const ms = parseInt(eventName.split(':')[1]);
         setInterval(async () => {
-            const handlerLocals = new Map(locals);
+            new Map(locals);
             for (const cmd of handler.commands) {
-                await executeCommand(cmd, me, handlerLocals);
+                await executeCommand(cmd, me);
             }
         }, ms);
         return me;
     }
     if (eventName === 'init') {
-        const handlerLocals = new Map(locals);
+        new Map(locals);
         for (const cmd of handler.commands) {
-            await executeCommand(cmd, me, handlerLocals);
+            await executeCommand(cmd, me);
         }
         return me;
     }
@@ -275,7 +284,7 @@ async function executeParsed(parsed, me, locals = new Map()) {
             const handlerLocals = new Map(locals);
             handlerLocals.set('event', event);
             for (const cmd of handler.commands) {
-                await executeCommand(cmd, me, handlerLocals);
+                await executeCommand(cmd, me);
             }
         });
     }
@@ -292,9 +301,9 @@ function evaluateCondition(expr, me, locals) {
         return Boolean(me[propMatch[2]]);
     }
     if (e.startsWith(':')) {
-        return Boolean(locals.get(e.slice(1)));
+        return Boolean(elemScope(me).get(e.slice(1)));
     }
-    const value = evaluateValue(e, me, locals);
+    const value = evaluateValue(e, me);
     return Boolean(value);
 }
 function processElements(root = document) {