@hyperfixi/core 2.9.1 → 2.9.3

package/dist/parser/command-parsers/utility-commands.d.ts

@@ -4,7 +4,7 @@ export declare function parseCompoundCommand(ctx: ParserContext, identifierNode:
 export declare function parseRegularCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
 export declare function parseMultiWordCommand(ctx: ParserContext, commandToken: Token, commandName: string): CommandNode | null;
 export declare function isNakedURLStart(ctx: ParserContext): boolean;
-export declare function parseBareURLPath(ctx: ParserContext, isTerminator?: (ctx: ParserContext) => boolean): ASTNode | null;
+export declare function parseBareURLPath(ctx: ParserContext): ASTNode | null;
 export declare function parseFetchCommand(ctx: ParserContext, commandToken: Token): CommandNode;
 export declare function parseJsCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
 export declare function parseTellCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;

package/dist/parser/full-parser.js

@@ -516,13 +516,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 === '[') {
@@ -538,24 +538,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 === '$') {
@@ -2762,7 +2762,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) {
@@ -3063,7 +3062,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)
@@ -3282,11 +3287,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) {
@@ -3299,6 +3357,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);
@@ -3307,9 +3373,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) {
@@ -3321,11 +3392,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();
         }
@@ -3340,11 +3415,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) {
@@ -3371,22 +3447,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");
         }
@@ -3412,19 +3474,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,
@@ -4246,21 +4296,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',
@@ -4282,7 +4317,7 @@ function parseGoCommand(ctx, identifierNode) {
             continue;
         }
         if (isNakedURLStart(ctx)) {
-            const url = parseBareURLPath(ctx, isGoURLTerminator);
+            const url = parseBareURLPath(ctx);
             if (url) {
                 args.push(url);
                 continue;
@@ -4422,13 +4457,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 === '/')
@@ -4439,23 +4467,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 = {};
@@ -4686,10 +4741,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()) {
@@ -4892,6 +4947,7 @@ class Parser {
         const result = this.parseInternal();
         if (this.errors.length > 0) {
             result.errors = [...this.errors];
+            result.recovered = true;
         }
         return result;
     }
@@ -6923,6 +6979,9 @@ class Parser {
                 this.advance();
                 const cmd = this.parseCommand();
                 commands.push(cmd);
+                if (this.match('then', 'and', ',')) {
+                    continue;
+                }
             }
             else {
                 break;