@hyperfixi/core 2.9.1 → 2.9.3

package/dist/registry/index.mjs

@@ -4138,13 +4138,13 @@ function tokenize(input) {
             continue;
         }
         if (char === '{') {
-            addToken(tokenizer, TokenKind.OPERATOR, '{');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, '{');
             continue;
         }
         if (char === '}') {
-            addToken(tokenizer, TokenKind.OPERATOR, '}');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, '}');
             continue;
         }
         if (char === '[') {
@@ -4160,24 +4160,24 @@ function tokenize(input) {
                     prevToken.value === ']') &&
                 !isEventCondition;
             if (isMemberAccess) {
-                addToken(tokenizer, TokenKind.OPERATOR, '[');
                 advance(tokenizer);
+                addToken(tokenizer, TokenKind.OPERATOR, '[');
             }
             else {
                 if (isEventCondition) {
-                    addToken(tokenizer, TokenKind.SYMBOL, '[');
                     advance(tokenizer);
+                    addToken(tokenizer, TokenKind.SYMBOL, '[');
                 }
                 else {
-                    addToken(tokenizer, TokenKind.OPERATOR, '[');
                     advance(tokenizer);
+                    addToken(tokenizer, TokenKind.OPERATOR, '[');
                 }
             }
             continue;
         }
         if (char === ']') {
-            addToken(tokenizer, TokenKind.OPERATOR, ']');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, ']');
             continue;
         }
         if (char === '$') {
@@ -5806,7 +5806,6 @@ const MULTI_WORD_PATTERNS = [
         keywords: ['a', 'an', 'from', 'called'],
         syntax: 'make (a|an) <type> [from <args>] [called <name>]',
     },
-    { command: 'send', keywords: ['to'], syntax: 'send <event> to <target>' },
     { command: 'throw', keywords: [], syntax: 'throw <error>' },
 ];
 function getMultiWordPattern(commandName) {
@@ -6107,7 +6106,13 @@ function parseTriggerCommand(ctx, identifierNode) {
             finalArgs.push(ctx.createIdentifier(keyword));
             continue;
         }
-        finalArgs.push(ctx.parsePrimary());
+        const before = ctx.savePosition();
+        const expr = ctx.parsePrimary();
+        if (expr)
+            finalArgs.push(expr);
+        if (ctx.savePosition() === before) {
+            ctx.advance();
+        }
     }
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...finalArgs)
@@ -6326,11 +6331,64 @@ function parseRepeatCommand(ctx, commandToken) {
     }
     return builder.endingAt(ctx.getPosition()).build();
 }
+function parseIfBranchCommands(ctx, stopAtElse) {
+    const commands = [];
+    const atTerminator = () => ctx.check(KEYWORDS.END) || (stopAtElse && ctx.check(KEYWORDS.ELSE));
+    while (!ctx.isAtEnd() && !atTerminator()) {
+        if (isComment(ctx.peek())) {
+            ctx.advance();
+            continue;
+        }
+        if (!ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value))
+            break;
+        ctx.advance();
+        const cmd = ctx.parseCommand();
+        if (cmd) {
+            commands.push(cmd);
+        }
+        if (ctx.check(KEYWORDS.THEN) || ctx.check(KEYWORDS.AND) || ctx.check(',')) {
+            ctx.advance();
+        }
+    }
+    return commands;
+}
+const OPERAND_INTRODUCERS = new Set([
+    'is',
+    'am',
+    'are',
+    'not',
+    'no',
+    'and',
+    'or',
+    '==',
+    '===',
+    '!=',
+    '!==',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    'mod',
+]);
+function isBodyCommandStart(ctx, prevToken, token) {
+    if (prevToken === null) {
+        return false;
+    }
+    if (OPERAND_INTRODUCERS.has(prevToken.value?.toLowerCase?.() ?? '')) {
+        return false;
+    }
+    return ctx.checkIsCommand() || ctx.isCommand(token.value?.toLowerCase());
+}
 function parseIfCommand(ctx, commandToken) {
     const args = [];
     let hasThen = false;
     const savedPosForThen = ctx.savePosition();
     const maxThenLookahead = 500;
+    let prevForThen = null;
     for (let i = 0; i < maxThenLookahead && !ctx.isAtEnd(); i++) {
         const token = ctx.peek();
         if (token.value === KEYWORDS.THEN) {
@@ -6343,6 +6401,14 @@ function parseIfCommand(ctx, commandToken) {
             token.value === KEYWORDS.ON) {
             break;
         }
+        if (token.line !== undefined &&
+            token.line !== commandToken.line &&
+            isBodyCommandStart(ctx, prevForThen, token)) {
+            break;
+        }
+        if (!isComment(token)) {
+            prevForThen = token;
+        }
         ctx.advance();
     }
     ctx.restorePosition(savedPosForThen);
@@ -6351,9 +6417,14 @@ function parseIfCommand(ctx, commandToken) {
         const savedPosition = ctx.savePosition();
         const ifStatementLine = commandToken.line;
         const maxLookahead = 100;
+        let firstCommandOnIfLine = false;
+        let prevToken = null;
         while (!ctx.isAtEnd() && ctx.current - savedPosition < maxLookahead) {
             const token = ctx.peek();
             const tokenValue = token.value?.toLowerCase();
+            if (firstCommandOnIfLine && token.line !== undefined && token.line !== ifStatementLine) {
+                break;
+            }
             if (tokenValue === KEYWORDS.BEHAVIOR ||
                 tokenValue === KEYWORDS.DEF ||
                 tokenValue === KEYWORDS.ON) {
@@ -6365,11 +6436,15 @@ function parseIfCommand(ctx, commandToken) {
                 }
                 break;
             }
-            if (ctx.checkIsCommand() || ctx.isCommand(tokenValue)) {
+            if (isBodyCommandStart(ctx, prevToken, token)) {
                 if (token.line !== undefined && token.line !== ifStatementLine) {
                     hasImplicitMultiLineEnd = true;
                     break;
                 }
+                firstCommandOnIfLine = true;
+            }
+            if (!isComment(token)) {
+                prevToken = token;
             }
             ctx.advance();
         }
@@ -6384,11 +6459,12 @@ function parseIfCommand(ctx, commandToken) {
         const conditionTokens = [];
         const maxIterations = 20;
         let iterations = 0;
+        let firstConditionParse = true;
         while (!ctx.isAtEnd() &&
-            !ctx.checkIsCommand() &&
-            !ctx.isCommand(ctx.peek().value) &&
             !ctx.check(KEYWORDS.THEN) &&
+            (firstConditionParse || (!ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value))) &&
             iterations < maxIterations) {
+            firstConditionParse = false;
             const beforePos = ctx.savePosition();
             conditionTokens.push(ctx.parseLogicalAnd());
             if (ctx.savePosition() === beforePos) {
@@ -6415,22 +6491,8 @@ function parseIfCommand(ctx, commandToken) {
     }
     args.push(condition);
     if (isMultiLine) {
-        if (hasThen) {
-            ctx.advance();
-        }
-        const thenCommands = [];
-        while (!ctx.isAtEnd() && !ctx.check(KEYWORDS.ELSE) && !ctx.check(KEYWORDS.END)) {
-            if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-                ctx.advance();
-                const cmd = ctx.parseCommand();
-                if (cmd) {
-                    thenCommands.push(cmd);
-                }
-            }
-            else {
-                break;
-            }
-        }
+        consumeOptionalKeyword(ctx, KEYWORDS.THEN);
+        const thenCommands = parseIfBranchCommands(ctx, true);
         if (thenCommands.length === 0 && ctx.isAtEnd()) {
             throw new Error("Expected command after 'then' in if statement - incomplete conditional");
         }
@@ -6456,19 +6518,7 @@ function parseIfCommand(ctx, commandToken) {
                 consumedElseIf = true;
             }
             else {
-                const elseCommands = [];
-                while (!ctx.isAtEnd() && !ctx.check(KEYWORDS.END)) {
-                    if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-                        ctx.advance();
-                        const cmd = ctx.parseCommand();
-                        if (cmd) {
-                            elseCommands.push(cmd);
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
+                const elseCommands = parseIfBranchCommands(ctx, false);
                 args.push(createBlock(elseCommands, {
                     start: commandToken.start,
                     end: ctx.getPosition().end,
@@ -7290,21 +7340,6 @@ const GO_KEYWORDS = new Set([
     'back',
     'forward',
 ]);
-const GO_URL_STOP = new Set([
-    'in',
-    'then',
-    'and',
-    'else',
-    'end',
-    'otherwise',
-    'when',
-    'where',
-    'catch',
-    'finally',
-]);
-function isGoURLTerminator(ctx) {
-    return ctx.isAtEnd() || GO_URL_STOP.has(ctx.peek().value);
-}
 function stringNode(value, tok) {
     return {
         type: 'string',
@@ -7326,7 +7361,7 @@ function parseGoCommand(ctx, identifierNode) {
             continue;
         }
         if (isNakedURLStart(ctx)) {
-            const url = parseBareURLPath(ctx, isGoURLTerminator);
+            const url = parseBareURLPath(ctx);
             if (url) {
                 args.push(url);
                 continue;
@@ -7466,13 +7501,6 @@ function parseMultiWordCommand(ctx, commandToken, commandName) {
     }
     return builder.build();
 }
-function isFetchURLTerminator(ctx) {
-    if (ctx.isAtEnd())
-        return true;
-    const val = ctx.peek().value;
-    return (['as', 'with', '{', 'then', 'end', 'else', 'otherwise', ')'].includes(val) ||
-        isCommandBoundary(ctx));
-}
 function isNakedURLStart(ctx) {
     const tok = ctx.peek();
     if (tok.value === '/')
@@ -7483,23 +7511,50 @@ function isNakedURLStart(ctx) {
     }
     return false;
 }
-function parseBareURLPath(ctx, isTerminator = isFetchURLTerminator) {
+const URL_HARD_STOPS = new Set(['{', ')']);
+function parseBareURLPath(ctx) {
     const startPos = ctx.savePosition();
+    const firstTok = ctx.peek();
     let path = '';
-    while (!ctx.isAtEnd() && !isTerminator(ctx)) {
-        path += ctx.advance().value;
+    let prev = null;
+    while (!ctx.isAtEnd()) {
+        const tok = ctx.peek();
+        if (prev && tok.start !== prev.end)
+            break;
+        if (tok.value === '$' && ctx.peekAt(1)?.value === '{') {
+            ctx.advance();
+            let last = ctx.advance();
+            let depth = 1;
+            while (!ctx.isAtEnd() && depth > 0) {
+                last = ctx.advance();
+                if (last.value === '{')
+                    depth++;
+                else if (last.value === '}')
+                    depth--;
+            }
+            path += ctx.getInputSlice(tok.start, last.end);
+            prev = last;
+            continue;
+        }
+        if (URL_HARD_STOPS.has(tok.value))
+            break;
+        prev = ctx.advance();
+        path += prev.value;
     }
     if (!path || path === '/') {
         ctx.restorePosition(startPos);
         return null;
     }
-    return {
-        type: 'literal',
-        value: path,
-        raw: path,
-        start: startPos,
-        end: ctx.savePosition(),
+    const span = {
+        start: firstTok.start,
+        end: prev ? prev.end : firstTok.end,
+        line: firstTok.line,
+        column: firstTok.column,
     };
+    if (path.includes('${')) {
+        return { type: 'templateLiteral', value: path, ...span };
+    }
+    return { type: 'literal', value: path, raw: path, ...span };
 }
 function parseFetchCommand(ctx, commandToken) {
     const modifiers = {};
@@ -7730,10 +7785,10 @@ function parseTellCommand(ctx, identifierNode) {
             catch {
                 break;
             }
-            if (ctx.match(KEYWORDS.AND)) {
+            if (ctx.match(KEYWORDS.AND) || ctx.match(KEYWORDS.THEN)) {
                 continue;
             }
-            if (ctx.check(KEYWORDS.THEN) || ctx.check(KEYWORDS.ELSE) || ctx.check(KEYWORDS.END)) {
+            if (ctx.check(KEYWORDS.ELSE) || ctx.check(KEYWORDS.END)) {
                 break;
             }
             if (ctx.checkIsCommand()) {
@@ -7936,6 +7991,7 @@ class Parser {
         const result = this.parseInternal();
         if (this.errors.length > 0) {
             result.errors = [...this.errors];
+            result.recovered = true;
         }
         return result;
     }
@@ -9967,6 +10023,9 @@ class Parser {
                 this.advance();
                 const cmd = this.parseCommand();
                 commands.push(cmd);
+                if (this.match('then', 'and', ',')) {
+                    continue;
+                }
             }
             else {
                 break;

package/dist/runtime/runtime-base.d.ts

@@ -1,4 +1,4 @@
-import type { ASTNode, ExecutionContext, CommandNode, EventHandlerNode } from '../types/base-types';
+import type { ASTNode, ExecutionContext, CommandNode, EventHandlerNode, DefNode } from '../types/base-types';
 import type { ExecutionResult, ExecutionSignal, ControlFlowError } from '../types/result';
 import type { RuntimeHooks } from '../types/hooks';
 import { HookRegistry } from '../types/hooks';
@@ -73,6 +73,7 @@ export declare class RuntimeBase {
     protected evaluateExpression(node: ASTNode, context: ExecutionContext): Promise<unknown>;
     protected evaluateExpressionWithResult(node: ASTNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
     protected executeCommandFromPattern(commandName: string, selector: string, context: ExecutionContext): Promise<unknown>;
+    protected installFunction(node: DefNode, context: ExecutionContext): void;
     protected executeProgram(node: ASTNode & {
         statements?: ASTNode[];
     }, context: ExecutionContext): Promise<unknown>;

package/dist/types/core.d.ts

@@ -120,6 +120,7 @@ export interface ParseResult<T = ASTNode> {
     ast?: T;
     error?: ParseError;
     errors?: ParseError[];
+    recovered?: boolean;
     warnings?: ParseWarning[];
     tokens: Token[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperfixi/core",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "Multilingual, tree-shakeable hyperscript",
   "type": "module",
   "main": "dist/index.js",
@@ -187,7 +187,7 @@
     "build:browser:multilingual": "rollup -c rollup.browser-multilingual.config.mjs",
     "build:browser:semantic-complete": "rollup -c rollup.browser-semantic-complete.config.mjs",
     "build:browser:all": "npm run build:browser:dev && npm run build:browser:prod && npm run build:browser:llm && npm run build:browser:lite && npm run build:browser:minimal && npm run build:browser:standard && npm run build:browser:classic && npm run build:browser:classic-i18n && npm run build:browser:multilingual && npm run build:browser:semantic-complete",
-    "build:browser:modular": "rollup -c rollup.browser-modular.config.mjs",
+    "build:browser:modular": "rm -rf dist/chunks && rollup -c rollup.browser-modular.config.mjs",
     "build:parser-modules": "rollup -c rollup.parser-modules.config.mjs",
     "snapshot:bundle-size": "node scripts/bundle-size-snapshot.mjs --check",
     "snapshot:bundle-size:update": "node scripts/bundle-size-snapshot.mjs --update",
@@ -279,14 +279,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@lokascript/intent": "^2.9.1",
-    "@lokascript/semantic": "^2.9.1",
+    "@lokascript/intent": "^2.9.3",
+    "@lokascript/semantic": "^2.9.3",
     "morphlex": "^1.4.0",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@hyperfixi/patterns-reference": "^2.9.1",
-    "@lokascript/framework": "^2.9.1"
+    "@hyperfixi/patterns-reference": "^2.9.3",
+    "@lokascript/framework": "^2.9.3"
   },
   "peerDependenciesMeta": {
     "@hyperfixi/patterns-reference": {