@hyperfixi/core 2.9.1 → 2.9.2

package/dist/parser/full-parser.mjs

@@ -514,13 +514,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 === '[') {
@@ -536,24 +536,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 === '$') {
@@ -2760,7 +2760,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) {
@@ -3061,7 +3060,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)
@@ -3280,11 +3285,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) {
@@ -3297,6 +3355,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);
@@ -3305,9 +3371,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) {
@@ -3319,11 +3390,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();
         }
@@ -3338,11 +3413,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) {
@@ -3369,22 +3445,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");
         }
@@ -3410,19 +3472,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,
@@ -4244,21 +4294,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',
@@ -4280,7 +4315,7 @@ function parseGoCommand(ctx, identifierNode) {
             continue;
         }
         if (isNakedURLStart(ctx)) {
-            const url = parseBareURLPath(ctx, isGoURLTerminator);
+            const url = parseBareURLPath(ctx);
             if (url) {
                 args.push(url);
                 continue;
@@ -4420,13 +4455,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 === '/')
@@ -4437,23 +4465,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 = {};
@@ -4684,10 +4739,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()) {
@@ -4890,6 +4945,7 @@ class Parser {
         const result = this.parseInternal();
         if (this.errors.length > 0) {
             result.errors = [...this.errors];
+            result.recovered = true;
         }
         return result;
     }
@@ -6921,6 +6977,9 @@ class Parser {
                 this.advance();
                 const cmd = this.parseCommand();
                 commands.push(cmd);
+                if (this.match('then', 'and', ',')) {
+                    continue;
+                }
             }
             else {
                 break;

package/dist/parser/hybrid/index.js

@@ -421,6 +421,9 @@ class HybridParser {
         if (cmdMap[normalized]) {
             return cmdMap[normalized]();
         }
+        if (this.match('catch', 'finally')) {
+            throw new Error(`'${this.peek().value}' needs the full parser (use hyperfixi.js)`);
+        }
         if (!this.isAtEnd() && !this.match('then', 'and', 'end', 'else')) {
             this.advance();
         }

package/dist/parser/hybrid/index.mjs

@@ -419,6 +419,9 @@ class HybridParser {
         if (cmdMap[normalized]) {
             return cmdMap[normalized]();
         }
+        if (this.match('catch', 'finally')) {
+            throw new Error(`'${this.peek().value}' needs the full parser (use hyperfixi.js)`);
+        }
         if (!this.isAtEnd() && !this.match('then', 'and', 'end', 'else')) {
             this.advance();
         }

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

@@ -415,6 +415,9 @@ class HybridParser {
         if (cmdMap[normalized]) {
             return cmdMap[normalized]();
         }
+        if (this.match('catch', 'finally')) {
+            throw new Error(`'${this.peek().value}' needs the full parser (use hyperfixi.js)`);
+        }
         if (!this.isAtEnd() && !this.match('then', 'and', 'end', 'else')) {
             this.advance();
         }

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

@@ -413,6 +413,9 @@ class HybridParser {
         if (cmdMap[normalized]) {
             return cmdMap[normalized]();
         }
+        if (this.match('catch', 'finally')) {
+            throw new Error(`'${this.peek().value}' needs the full parser (use hyperfixi.js)`);
+        }
         if (!this.isAtEnd() && !this.match('then', 'and', 'end', 'else')) {
             this.advance();
         }

package/dist/parser/hybrid-parser.js

@@ -421,6 +421,9 @@ class HybridParser {
         if (cmdMap[normalized]) {
             return cmdMap[normalized]();
         }
+        if (this.match('catch', 'finally')) {
+            throw new Error(`'${this.peek().value}' needs the full parser (use hyperfixi.js)`);
+        }
         if (!this.isAtEnd() && !this.match('then', 'and', 'end', 'else')) {
             this.advance();
         }

package/dist/parser/hybrid-parser.mjs

@@ -419,6 +419,9 @@ class HybridParser {
         if (cmdMap[normalized]) {
             return cmdMap[normalized]();
         }
+        if (this.match('catch', 'finally')) {
+            throw new Error(`'${this.peek().value}' needs the full parser (use hyperfixi.js)`);
+        }
         if (!this.isAtEnd() && !this.match('then', 'and', 'end', 'else')) {
             this.advance();
         }

package/dist/reference/index.js

@@ -177,6 +177,7 @@ const commands = {
         examples: [
             'fetch /api/data as json',
             'fetch https://example.com/api as json',
+            'fetch /api/${id} as json',
             'fetch /api/users as html',
             'fetch /api/submit with method:"POST"',
         ],

package/dist/reference/index.mjs

@@ -175,6 +175,7 @@ const commands = {
         examples: [
             'fetch /api/data as json',
             'fetch https://example.com/api as json',
+            'fetch /api/${id} as json',
             'fetch /api/users as html',
             'fetch /api/submit with method:"POST"',
         ],