@hyperfixi/core 2.0.0 → 2.2.0

package/dist/parser/helpers/ast-helpers.d.ts

@@ -18,5 +18,6 @@ export declare function createArrayLiteral(elements: ASTNode[], pos: Position):
 export declare function createPropertyOfExpression(property: ASTNode, target: ASTNode, pos: Position): PropertyOfExpressionNode;
 export declare function createCommandSequence(commands: ASTNode[]): CommandSequenceNode;
 export declare function createErrorNode(pos: Position): IdentifierNode;
+export declare function createErrorCommandNode(pos: Position, message: string, source?: string): ASTNode;
 export declare function createProgramNode(statements: ASTNode[]): ASTNode;
 //# sourceMappingURL=ast-helpers.d.ts.map

package/dist/parser/hybrid/index.js

@@ -78,6 +78,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];
@@ -403,6 +408,7 @@ class HybridParser {
             go: () => this.parseGo(),
             return: () => this.parseReturn(),
             transition: () => this.parseTransition(),
+            halt: () => this.parseHalt(),
         };
         const normalized = normalizeCommand(this.peek().value);
         if (cmdMap[normalized]) {
@@ -470,11 +476,17 @@ class HybridParser {
         const url = this.parseExpression();
         let responseType = { type: 'literal', value: 'text' };
         let options;
+        let method;
         if (this.match('{')) {
             this.pos--;
             options = this.parseExpression();
         }
-        for (let i = 0; i < 2; i++) {
+        for (let i = 0; i < 3; i++) {
+            if (this.match('via') && !method) {
+                this.advance();
+                method = this.parseExpression();
+                continue;
+            }
             if (this.match('as')) {
                 this.advance();
                 if (this.match('a') || this.match('an'))
@@ -492,7 +504,11 @@ class HybridParser {
         if (this.match('then'))
             this.advance();
         const body = this.parseCommandSequence();
-        return { type: 'fetch', condition: { type: 'fetchConfig', url, responseType, options }, body };
+        return {
+            type: 'fetch',
+            condition: { type: 'fetchConfig', url, responseType, options, method },
+            body,
+        };
     }
     parseToggle() {
         this.expect('toggle');
@@ -683,6 +699,14 @@ class HybridParser {
         }
         return { type: 'command', name: 'return', args: value ? [value] : [] };
     }
+    parseHalt() {
+        this.expect('halt');
+        if (this.match('the'))
+            this.advance();
+        if (this.match('event', 'default'))
+            this.advance();
+        return { type: 'command', name: 'halt', args: [] };
+    }
     parseTransition() {
         this.expect('transition');
         let target;
@@ -959,6 +983,15 @@ class HybridParser {
             const target = this.parsePositionalTarget();
             return { type: 'positional', position, target };
         }
+        if (this.match('values')) {
+            this.advance();
+            if (this.match('of')) {
+                this.advance();
+                const target = this.parseExpression();
+                return { type: 'valuesOf', target };
+            }
+            return { type: 'identifier', value: token.value };
+        }
         if (token.type === 'identifier' || token.type === 'keyword') {
             this.advance();
             return { type: 'identifier', value: token.value };

package/dist/parser/hybrid/index.mjs

@@ -76,6 +76,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];
@@ -401,6 +406,7 @@ class HybridParser {
             go: () => this.parseGo(),
             return: () => this.parseReturn(),
             transition: () => this.parseTransition(),
+            halt: () => this.parseHalt(),
         };
         const normalized = normalizeCommand(this.peek().value);
         if (cmdMap[normalized]) {
@@ -468,11 +474,17 @@ class HybridParser {
         const url = this.parseExpression();
         let responseType = { type: 'literal', value: 'text' };
         let options;
+        let method;
         if (this.match('{')) {
             this.pos--;
             options = this.parseExpression();
         }
-        for (let i = 0; i < 2; i++) {
+        for (let i = 0; i < 3; i++) {
+            if (this.match('via') && !method) {
+                this.advance();
+                method = this.parseExpression();
+                continue;
+            }
             if (this.match('as')) {
                 this.advance();
                 if (this.match('a') || this.match('an'))
@@ -490,7 +502,11 @@ class HybridParser {
         if (this.match('then'))
             this.advance();
         const body = this.parseCommandSequence();
-        return { type: 'fetch', condition: { type: 'fetchConfig', url, responseType, options }, body };
+        return {
+            type: 'fetch',
+            condition: { type: 'fetchConfig', url, responseType, options, method },
+            body,
+        };
     }
     parseToggle() {
         this.expect('toggle');
@@ -681,6 +697,14 @@ class HybridParser {
         }
         return { type: 'command', name: 'return', args: value ? [value] : [] };
     }
+    parseHalt() {
+        this.expect('halt');
+        if (this.match('the'))
+            this.advance();
+        if (this.match('event', 'default'))
+            this.advance();
+        return { type: 'command', name: 'halt', args: [] };
+    }
     parseTransition() {
         this.expect('transition');
         let target;
@@ -957,6 +981,15 @@ class HybridParser {
             const target = this.parsePositionalTarget();
             return { type: 'positional', position, target };
         }
+        if (this.match('values')) {
+            this.advance();
+            if (this.match('of')) {
+                this.advance();
+                const target = this.parseExpression();
+                return { type: 'valuesOf', target };
+            }
+            return { type: 'identifier', value: token.value };
+        }
         if (token.type === 'identifier' || token.type === 'keyword') {
             this.advance();
             return { type: 'identifier', value: token.value };

package/dist/parser/hybrid/parser-core.d.ts

@@ -37,6 +37,7 @@ export declare class HybridParser {
     private parseFocusBlur;
     private parseGo;
     private parseReturn;
+    private parseHalt;
     private parseTransition;
     private parseTransitionRest;
     private parseExpression;

package/dist/parser/hybrid/parser-core.js

@@ -78,6 +78,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];
@@ -397,6 +402,7 @@ class HybridParser {
             go: () => this.parseGo(),
             return: () => this.parseReturn(),
             transition: () => this.parseTransition(),
+            halt: () => this.parseHalt(),
         };
         const normalized = normalizeCommand(this.peek().value);
         if (cmdMap[normalized]) {
@@ -464,11 +470,17 @@ class HybridParser {
         const url = this.parseExpression();
         let responseType = { type: 'literal', value: 'text' };
         let options;
+        let method;
         if (this.match('{')) {
             this.pos--;
             options = this.parseExpression();
         }
-        for (let i = 0; i < 2; i++) {
+        for (let i = 0; i < 3; i++) {
+            if (this.match('via') && !method) {
+                this.advance();
+                method = this.parseExpression();
+                continue;
+            }
             if (this.match('as')) {
                 this.advance();
                 if (this.match('a') || this.match('an'))
@@ -486,7 +498,11 @@ class HybridParser {
         if (this.match('then'))
             this.advance();
         const body = this.parseCommandSequence();
-        return { type: 'fetch', condition: { type: 'fetchConfig', url, responseType, options }, body };
+        return {
+            type: 'fetch',
+            condition: { type: 'fetchConfig', url, responseType, options, method },
+            body,
+        };
     }
     parseToggle() {
         this.expect('toggle');
@@ -677,6 +693,14 @@ class HybridParser {
         }
         return { type: 'command', name: 'return', args: value ? [value] : [] };
     }
+    parseHalt() {
+        this.expect('halt');
+        if (this.match('the'))
+            this.advance();
+        if (this.match('event', 'default'))
+            this.advance();
+        return { type: 'command', name: 'halt', args: [] };
+    }
     parseTransition() {
         this.expect('transition');
         let target;
@@ -953,6 +977,15 @@ class HybridParser {
             const target = this.parsePositionalTarget();
             return { type: 'positional', position, target };
         }
+        if (this.match('values')) {
+            this.advance();
+            if (this.match('of')) {
+                this.advance();
+                const target = this.parseExpression();
+                return { type: 'valuesOf', target };
+            }
+            return { type: 'identifier', value: token.value };
+        }
         if (token.type === 'identifier' || token.type === 'keyword') {
             this.advance();
             return { type: 'identifier', value: token.value };

package/dist/parser/hybrid/parser-core.mjs

@@ -76,6 +76,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];
@@ -395,6 +400,7 @@ class HybridParser {
             go: () => this.parseGo(),
             return: () => this.parseReturn(),
             transition: () => this.parseTransition(),
+            halt: () => this.parseHalt(),
         };
         const normalized = normalizeCommand(this.peek().value);
         if (cmdMap[normalized]) {
@@ -462,11 +468,17 @@ class HybridParser {
         const url = this.parseExpression();
         let responseType = { type: 'literal', value: 'text' };
         let options;
+        let method;
         if (this.match('{')) {
             this.pos--;
             options = this.parseExpression();
         }
-        for (let i = 0; i < 2; i++) {
+        for (let i = 0; i < 3; i++) {
+            if (this.match('via') && !method) {
+                this.advance();
+                method = this.parseExpression();
+                continue;
+            }
             if (this.match('as')) {
                 this.advance();
                 if (this.match('a') || this.match('an'))
@@ -484,7 +496,11 @@ class HybridParser {
         if (this.match('then'))
             this.advance();
         const body = this.parseCommandSequence();
-        return { type: 'fetch', condition: { type: 'fetchConfig', url, responseType, options }, body };
+        return {
+            type: 'fetch',
+            condition: { type: 'fetchConfig', url, responseType, options, method },
+            body,
+        };
     }
     parseToggle() {
         this.expect('toggle');
@@ -675,6 +691,14 @@ class HybridParser {
         }
         return { type: 'command', name: 'return', args: value ? [value] : [] };
     }
+    parseHalt() {
+        this.expect('halt');
+        if (this.match('the'))
+            this.advance();
+        if (this.match('event', 'default'))
+            this.advance();
+        return { type: 'command', name: 'halt', args: [] };
+    }
     parseTransition() {
         this.expect('transition');
         let target;
@@ -951,6 +975,15 @@ class HybridParser {
             const target = this.parsePositionalTarget();
             return { type: 'positional', position, target };
         }
+        if (this.match('values')) {
+            this.advance();
+            if (this.match('of')) {
+                this.advance();
+                const target = this.parseExpression();
+                return { type: 'valuesOf', target };
+            }
+            return { type: 'identifier', value: token.value };
+        }
         if (token.type === 'identifier' || token.type === 'keyword') {
             this.advance();
             return { type: 'identifier', value: token.value };

package/dist/parser/hybrid/tokenizer.js

@@ -78,6 +78,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];

package/dist/parser/hybrid/tokenizer.mjs

@@ -76,6 +76,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];

package/dist/parser/hybrid-parser.js

@@ -78,6 +78,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];
@@ -403,6 +408,7 @@ class HybridParser {
             go: () => this.parseGo(),
             return: () => this.parseReturn(),
             transition: () => this.parseTransition(),
+            halt: () => this.parseHalt(),
         };
         const normalized = normalizeCommand(this.peek().value);
         if (cmdMap[normalized]) {
@@ -470,11 +476,17 @@ class HybridParser {
         const url = this.parseExpression();
         let responseType = { type: 'literal', value: 'text' };
         let options;
+        let method;
         if (this.match('{')) {
             this.pos--;
             options = this.parseExpression();
         }
-        for (let i = 0; i < 2; i++) {
+        for (let i = 0; i < 3; i++) {
+            if (this.match('via') && !method) {
+                this.advance();
+                method = this.parseExpression();
+                continue;
+            }
             if (this.match('as')) {
                 this.advance();
                 if (this.match('a') || this.match('an'))
@@ -492,7 +504,11 @@ class HybridParser {
         if (this.match('then'))
             this.advance();
         const body = this.parseCommandSequence();
-        return { type: 'fetch', condition: { type: 'fetchConfig', url, responseType, options }, body };
+        return {
+            type: 'fetch',
+            condition: { type: 'fetchConfig', url, responseType, options, method },
+            body,
+        };
     }
     parseToggle() {
         this.expect('toggle');
@@ -683,6 +699,14 @@ class HybridParser {
         }
         return { type: 'command', name: 'return', args: value ? [value] : [] };
     }
+    parseHalt() {
+        this.expect('halt');
+        if (this.match('the'))
+            this.advance();
+        if (this.match('event', 'default'))
+            this.advance();
+        return { type: 'command', name: 'halt', args: [] };
+    }
     parseTransition() {
         this.expect('transition');
         let target;
@@ -959,6 +983,15 @@ class HybridParser {
             const target = this.parsePositionalTarget();
             return { type: 'positional', position, target };
         }
+        if (this.match('values')) {
+            this.advance();
+            if (this.match('of')) {
+                this.advance();
+                const target = this.parseExpression();
+                return { type: 'valuesOf', target };
+            }
+            return { type: 'identifier', value: token.value };
+        }
         if (token.type === 'identifier' || token.type === 'keyword') {
             this.advance();
             return { type: 'identifier', value: token.value };

package/dist/parser/hybrid-parser.mjs

@@ -76,6 +76,11 @@ const KEYWORDS = new Set([
     'init',
     'every',
     'by',
+    'halt',
+    'via',
+    'values',
+    'default',
+    'event',
 ]);
 function tokenize(code) {
     const tokens = [];
@@ -401,6 +406,7 @@ class HybridParser {
             go: () => this.parseGo(),
             return: () => this.parseReturn(),
             transition: () => this.parseTransition(),
+            halt: () => this.parseHalt(),
         };
         const normalized = normalizeCommand(this.peek().value);
         if (cmdMap[normalized]) {
@@ -468,11 +474,17 @@ class HybridParser {
         const url = this.parseExpression();
         let responseType = { type: 'literal', value: 'text' };
         let options;
+        let method;
         if (this.match('{')) {
             this.pos--;
             options = this.parseExpression();
         }
-        for (let i = 0; i < 2; i++) {
+        for (let i = 0; i < 3; i++) {
+            if (this.match('via') && !method) {
+                this.advance();
+                method = this.parseExpression();
+                continue;
+            }
             if (this.match('as')) {
                 this.advance();
                 if (this.match('a') || this.match('an'))
@@ -490,7 +502,11 @@ class HybridParser {
         if (this.match('then'))
             this.advance();
         const body = this.parseCommandSequence();
-        return { type: 'fetch', condition: { type: 'fetchConfig', url, responseType, options }, body };
+        return {
+            type: 'fetch',
+            condition: { type: 'fetchConfig', url, responseType, options, method },
+            body,
+        };
     }
     parseToggle() {
         this.expect('toggle');
@@ -681,6 +697,14 @@ class HybridParser {
         }
         return { type: 'command', name: 'return', args: value ? [value] : [] };
     }
+    parseHalt() {
+        this.expect('halt');
+        if (this.match('the'))
+            this.advance();
+        if (this.match('event', 'default'))
+            this.advance();
+        return { type: 'command', name: 'halt', args: [] };
+    }
     parseTransition() {
         this.expect('transition');
         let target;
@@ -957,6 +981,15 @@ class HybridParser {
             const target = this.parsePositionalTarget();
             return { type: 'positional', position, target };
         }
+        if (this.match('values')) {
+            this.advance();
+            if (this.match('of')) {
+                this.advance();
+                const target = this.parseExpression();
+                return { type: 'valuesOf', target };
+            }
+            return { type: 'identifier', value: token.value };
+        }
         if (token.type === 'identifier' || token.type === 'keyword') {
             this.advance();
             return { type: 'identifier', value: token.value };

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

@@ -1,5 +1,4 @@
 import type { Token, ASTNode, CommandNode } from '../types/core';
-import { TokenType } from './tokenizer';
 export interface Position {
     start: number;
     end: number;
@@ -86,14 +85,20 @@ export interface MultiWordPattern {
     minArgs?: number;
     maxArgs?: number;
 }
-export interface ParserContext {
+export interface TokenStream {
     readonly tokens: Token[];
     current: number;
     advance(): Token;
     peek(): Token;
     previous(): Token;
-    consume(expected: string | TokenType, message: string): Token;
+    consume(expected: string, message: string): Token;
     check(value: string): boolean;
+    match(...types: string[]): boolean;
+    matchOperator(operator: string): boolean;
+    isAtEnd(): boolean;
+    peekAt(offset: number): Token | null;
+}
+export interface TokenPredicates {
     checkIdentifierLike(): boolean;
     checkSelector(): boolean;
     checkAnySelector(): boolean;
@@ -103,9 +108,8 @@ export interface ParserContext {
     checkEvent(): boolean;
     checkIsCommand(): boolean;
     checkContextVar(): boolean;
-    match(...types: Array<string | TokenType>): boolean;
-    matchOperator(operator: string): boolean;
-    isAtEnd(): boolean;
+}
+export interface ASTFactory {
     createIdentifier(name: string): IdentifierNode;
     createLiteral(value: unknown, raw: string): ASTNode;
     createSelector(value: string): ASTNode;
@@ -117,6 +121,8 @@ export interface ParserContext {
     createErrorNode(): ASTNode;
     createProgramNode(statements: ASTNode[]): ASTNode;
     createCommandFromIdentifier(identifierNode: IdentifierNode): CommandNode;
+}
+export interface ExpressionParser {
     parseExpression(): ASTNode;
     parsePrimary(): ASTNode;
     parseCall(): ASTNode;
@@ -139,15 +145,22 @@ export interface ParserContext {
     parseAttributeOrArrayLiteral(): ASTNode;
     parseObjectLiteral(): ASTNode;
     parseCSSObjectLiteral(): ASTNode;
+}
+export interface CommandParser {
     parseCommand(): CommandNode;
     parseCommandSequence(): ASTNode;
     parseCommandListUntilEnd(): ASTNode[];
+}
+export interface PositionCheckpoint {
     savePosition(): number;
     restorePosition(pos: number): void;
-    peekAt(offset: number): Token | null;
     getPosition(): Position;
+}
+export interface ParserErrorHandler {
     addError(message: string): void;
     addWarning(warning: string): void;
+}
+export interface ParserUtilities {
     isCommand(name: string): boolean;
     isCompoundCommand(name: string): boolean;
     isKeyword(name: string): boolean;
@@ -155,6 +168,8 @@ export interface ParserContext {
     resolveKeyword(value: string): string;
     getInputSlice(start: number, end?: number): string;
 }
+export interface ParserContext extends TokenStream, TokenPredicates, ASTFactory, ExpressionParser, CommandParser, PositionCheckpoint, ParserErrorHandler, ParserUtilities {
+}
 export type CommandParserFunction = (token: Token, context: ParserContext) => CommandNode;
 export type CompoundCommandParserFunction = (identifierNode: IdentifierNode, context: ParserContext) => CommandNode | null;
 export type TokenNavigationFunction = (context: ParserContext) => Token | boolean;

package/dist/parser/parser.d.ts

@@ -6,17 +6,23 @@ export declare class Parser {
     private tokens;
     private current;
     private error;
+    private errors;
     private warnings;
     private keywordResolver?;
     private semanticAdapter?;
     private originalInput?;
     private registryIntegration?;
+    private prattCache;
     private static readonly POSTFIX_UNARY_OPERATORS;
     constructor(tokens: Token[], options?: ParserOptions, originalInput?: string);
     private resolveKeyword;
     private addWarning;
     parse(): ParseResult;
+    private parseInternal;
     private parseExpression;
+    private static readonly PRATT_TABLE;
+    private parseExpressionPratt;
+    private makePrattContext;
     private parseAssignment;
     private parseLogicalOr;
     private parseLogicalAnd;
@@ -138,6 +144,7 @@ export declare class Parser {
     private previous;
     private consume;
     private addError;
+    private synchronizeToCommandBoundary;
     private parseAttributeOrArrayLiteral;
     private getPosition;
     getContext(): import('./parser-types').ParserContext;