@futpib/parser 1.0.6 → 1.0.7

package/build/bashParser.js

@@ -1,33 +1,88 @@
 import { setParserName } from './parser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createElementParser } from './elementParser.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createLookaheadParser } from './lookaheadParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createArrayParser } from './arrayParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createOptionalParser } from './optionalParser.js';
-import { createRegExpParser } from './regexpParser.js';
 import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
 import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
 import { createObjectParser } from './objectParser.js';
+// Character predicates
+function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+}
+function isLetter(ch) {
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+}
+function isIdentStart(ch) {
+    return isLetter(ch) || ch === '_';
+}
+function isIdentChar(ch) {
+    return isIdentStart(ch) || isDigit(ch);
+}
 // Whitespace (spaces, tabs, and line continuations - not bare newlines which are significant)
-const bashInlineWhitespaceParser = promiseCompose(createRegExpParser(/(?:[ \t]|\\\n)+/), match => match[0]);
-const bashOptionalInlineWhitespaceParser = promiseCompose(createRegExpParser(/(?:[ \t]|\\\n)*/), match => match[0]);
-// Newline
-const bashNewlineParser = promiseCompose(createRegExpParser(/\n/), match => match[0]);
+const bashInlineWhitespaceUnitParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser(' '), () => ' '),
+    promiseCompose(createExactSequenceParser('\t'), () => '\t'),
+    promiseCompose(createExactSequenceParser('\\\n'), () => '\\\n'),
+]);
+const bashInlineWhitespaceParser = promiseCompose(createNonEmptyArrayParser(bashInlineWhitespaceUnitParser), parts => parts.join(''));
+const bashOptionalInlineWhitespaceParser = promiseCompose(createArrayParser(bashInlineWhitespaceUnitParser), parts => parts.join(''));
 // Word characters (unquoted, no special chars)
-// Note: {} are excluded so brace groups are parsed correctly
-// # is excluded from the first character (starts a comment) but allowed mid-word
-const bashUnquotedWordCharsParser = promiseCompose(createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#][^\s\n|&;<>(){}$`"'\\]*/), match => match[0]);
+// Note: {} and # are excluded from the first character so brace groups and comments are parsed correctly,
+// but allowed as continuation characters for mid-word braces (e.g., file.{c,h}, foo}bar) and hash (foo#bar)
+const bashSpecialCharParser = createDisjunctionParser([...' \t\n|&;<>()$`"\'\\'].map(ch => createExactSequenceParser(ch)));
+const bashWordStartExcludeParser = createDisjunctionParser([
+    bashSpecialCharParser,
+    createExactSequenceParser('{'),
+    createExactSequenceParser('}'),
+    createExactSequenceParser('#'),
+]);
+const bashUnquotedWordStartCharParser = promiseCompose(createTupleParser([
+    createNegativeLookaheadParser(bashWordStartExcludeParser),
+    createElementParser(),
+]), ([, ch]) => ch);
+const bashUnquotedWordContinueCharParser = promiseCompose(createTupleParser([
+    createNegativeLookaheadParser(bashSpecialCharParser),
+    createElementParser(),
+]), ([, ch]) => ch);
+const bashUnquotedWordCharsParser = promiseCompose(createTupleParser([
+    bashUnquotedWordStartCharParser,
+    createArrayParser(bashUnquotedWordContinueCharParser),
+]), ([first, rest]) => first + rest.join(''));
+// Consume characters until a given terminator, returning the accumulated string
+function createUntilCharParser(terminator) {
+    return promiseCompose(createArrayParser(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([, ch]) => ch)), chars => chars.join(''));
+}
 // Single quoted string: '...'
 const bashSingleQuotedParser = createObjectParser({
     type: 'singleQuoted',
     _open: createExactSequenceParser("'"),
-    value: promiseCompose(createRegExpParser(/[^']*/), match => match[0]),
+    value: createUntilCharParser("'"),
     _close: createExactSequenceParser("'"),
 });
-// Variable name
-const bashVariableNameParser = promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*|[0-9]+|[@*#?$!-]/), match => match[0]);
+// Variable name: identifiers, positional params ($0, $1...), or special params ($@, $*, $#, $?, $$, $!, $-)
+const bashSpecialParams = new Set(['@', '*', '#', '?', '$', '!', '-']);
+const bashIdentifierParser = promiseCompose(createTupleParser([
+    createPredicateElementParser(isIdentStart),
+    createArrayParser(createPredicateElementParser(isIdentChar)),
+]), ([first, rest]) => first + rest.join(''));
+const bashDigitsParser = promiseCompose(createNonEmptyArrayParser(createPredicateElementParser(isDigit)), chars => chars.join(''));
+const bashSpecialParamParser = createPredicateElementParser(ch => bashSpecialParams.has(ch));
+const bashVariableNameParser = createDisjunctionParser([
+    bashIdentifierParser,
+    bashDigitsParser,
+    bashSpecialParamParser,
+]);
 // Simple variable: $var
 const bashSimpleVariableParser = createObjectParser({
     type: 'variable',
@@ -50,40 +105,148 @@ const bashBacktickSubstitutionParser = createObjectParser({
     command: createParserAccessorParser(() => bashCommandParser),
     _close: createExactSequenceParser('`'),
 });
+// Word characters for use inside ${...} operands (} excluded from continuation to not consume the closing brace)
+const bashBracedVarContinueExcludeParser = createDisjunctionParser([
+    bashSpecialCharParser,
+    createExactSequenceParser('{'),
+    createExactSequenceParser('}'),
+]);
+const bashBracedVarUnquotedWordCharsParser = promiseCompose(createTupleParser([
+    bashUnquotedWordStartCharParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(bashBracedVarContinueExcludeParser),
+        createElementParser(),
+    ]), ([, ch]) => ch)),
+]), ([first, rest]) => first + rest.join(''));
+const bashBracedVarLiteralWordPartParser = createObjectParser({
+    type: 'literal',
+    value: bashBracedVarUnquotedWordCharsParser,
+});
 // Braced variable expansion: ${VAR} or ${VAR:-default}
 const bashBracedVariableParser = createObjectParser({
     type: 'variableBraced',
     _open: createExactSequenceParser('${'),
     name: bashVariableNameParser,
-    operator: createOptionalParser(promiseCompose(createRegExpParser(/:-|:=|:\+|:\?|-|=|\+|\?|##|#|%%|%/), match => match[0])),
-    operand: createOptionalParser(createParserAccessorParser(() => bashWordParser)),
+    operator: createOptionalParser(createDisjunctionParser([
+        promiseCompose(createExactSequenceParser(':-'), () => ':-'),
+        promiseCompose(createExactSequenceParser(':='), () => ':='),
+        promiseCompose(createExactSequenceParser(':+'), () => ':+'),
+        promiseCompose(createExactSequenceParser(':?'), () => ':?'),
+        promiseCompose(createExactSequenceParser('##'), () => '##'),
+        promiseCompose(createExactSequenceParser('%%'), () => '%%'),
+        promiseCompose(createExactSequenceParser('-'), () => '-'),
+        promiseCompose(createExactSequenceParser('='), () => '='),
+        promiseCompose(createExactSequenceParser('+'), () => '+'),
+        promiseCompose(createExactSequenceParser('?'), () => '?'),
+        promiseCompose(createExactSequenceParser('#'), () => '#'),
+        promiseCompose(createExactSequenceParser('%'), () => '%'),
+    ])),
+    operand: createOptionalParser(createParserAccessorParser(() => bashBracedVarWordParser)),
     _close: createExactSequenceParser('}'),
 });
-// Arithmetic expansion: $((expression))
+// Arithmetic expansion: $((expression)) - handles nested parentheses
+const bashArithmeticExpressionParser = async (parserContext) => {
+    let result = '';
+    let depth = 0;
+    for (;;) {
+        const ch = await parserContext.peek(0);
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === '(') {
+            depth++;
+            result += ch;
+            parserContext.skip(1);
+            continue;
+        }
+        if (ch === ')') {
+            if (depth > 0) {
+                depth--;
+                result += ch;
+                parserContext.skip(1);
+                continue;
+            }
+            // At depth 0, a ')' means we've hit the closing '))' of $((
+            break;
+        }
+        result += ch;
+        parserContext.skip(1);
+    }
+    return result;
+};
 const bashArithmeticExpansionParser = createObjectParser({
     type: 'arithmeticExpansion',
     _open: createExactSequenceParser('$(('),
-    expression: promiseCompose(createRegExpParser(/(?:[^)]|\)(?!\)))*/), match => match[0]),
+    expression: bashArithmeticExpressionParser,
     _close: createExactSequenceParser('))'),
 });
-// ANSI-C quoting: $'...'
+// ANSI-C quoting: $'...' - content can include \' escapes
+// Each unit is either a backslash-escape pair or a non-quote character
+const bashAnsiCContentUnitParser = createDisjunctionParser([
+    // Backslash escape: \x (any char after backslash)
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('\\'),
+        createElementParser(),
+    ]), ([bs, ch]) => bs + ch),
+    // Any character that isn't ' (and isn't \ which is handled above)
+    promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser("'")),
+        createElementParser(),
+    ]), ([, ch]) => ch),
+]);
+const bashAnsiCContentParser = promiseCompose(createArrayParser(bashAnsiCContentUnitParser), parts => parts.join(''));
 const bashAnsiCQuotedParser = createObjectParser({
     type: 'singleQuoted',
     _prefix: createExactSequenceParser('$'),
     _open: createExactSequenceParser("'"),
-    value: promiseCompose(createRegExpParser(/(?:[^'\\]|\\.)*/), match => match[0]),
+    value: bashAnsiCContentParser,
     _close: createExactSequenceParser("'"),
 });
 // Process substitution: <(cmd) or >(cmd)
+const bashProcessSubstitutionDirectionParser = promiseCompose(createTupleParser([
+    createDisjunctionParser([
+        createExactSequenceParser('<'),
+        createExactSequenceParser('>'),
+    ]),
+    createLookaheadParser(createExactSequenceParser('(')),
+]), ([dir]) => dir);
 const bashProcessSubstitutionParser = createObjectParser({
     type: 'processSubstitution',
-    direction: promiseCompose(createRegExpParser(/[<>](?=\()/), match => match[0]),
+    direction: bashProcessSubstitutionDirectionParser,
     _open: createExactSequenceParser('('),
     _ws1: bashOptionalInlineWhitespaceParser,
     command: createParserAccessorParser(() => bashCommandParser),
     _ws2: bashOptionalInlineWhitespaceParser,
     _close: createExactSequenceParser(')'),
 });
+// Escape sequences in double quotes: \\ \$ \` \" \! \newline
+const bashDoubleQuotedEscapeCharParser = createDisjunctionParser([
+    createExactSequenceParser('\\'),
+    createExactSequenceParser('$'),
+    createExactSequenceParser('`'),
+    createExactSequenceParser('"'),
+    createExactSequenceParser('!'),
+    createExactSequenceParser('\n'),
+]);
+const bashDoubleQuotedEscapeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\'),
+    bashDoubleQuotedEscapeCharParser,
+]), ([, ch]) => ({ type: 'literal', value: ch }));
+// Literal text inside double quotes (no special chars)
+const bashDoubleQuotedLiteralCharParser = promiseCompose(createTupleParser([
+    createNegativeLookaheadParser(createDisjunctionParser([
+        createExactSequenceParser('$'),
+        createExactSequenceParser('`'),
+        createExactSequenceParser('"'),
+        createExactSequenceParser('\\'),
+    ])),
+    createElementParser(),
+]), ([, ch]) => ch);
+const bashDoubleQuotedLiteralParser = promiseCompose(createNonEmptyArrayParser(bashDoubleQuotedLiteralCharParser), chars => ({ type: 'literal', value: chars.join('') }));
+// Bare $ not followed by a valid expansion start
+const bashBareDollarParser = promiseCompose(createExactSequenceParser('$'), () => ({ type: 'literal', value: '$' }));
+// Bare \ not followed by a recognized escape character
+const bashBareBackslashParser = promiseCompose(createExactSequenceParser('\\'), () => ({ type: 'literal', value: '\\' }));
 // Double quoted string parts (inside "...")
 const bashDoubleQuotedPartParser = createDisjunctionParser([
     bashBracedVariableParser,
@@ -91,26 +254,10 @@ const bashDoubleQuotedPartParser = createDisjunctionParser([
     bashSimpleVariableParser,
     bashCommandSubstitutionParser,
     bashBacktickSubstitutionParser,
-    // Escape sequences in double quotes
-    promiseCompose(createRegExpParser(/\\[\\$`"!\n]/), match => ({
-        type: 'literal',
-        value: match[0].slice(1),
-    })),
-    // Literal text (no special chars)
-    promiseCompose(createRegExpParser(/[^$`"\\]+/), match => ({
-        type: 'literal',
-        value: match[0],
-    })),
-    // Bare $ not followed by a valid expansion start (e.g. $" at end of double-quoted string)
-    promiseCompose(createRegExpParser(/\$/), () => ({
-        type: 'literal',
-        value: '$',
-    })),
-    // Bare \ not followed by a recognized escape character (treated as literal backslash in bash)
-    promiseCompose(createRegExpParser(/\\/), () => ({
-        type: 'literal',
-        value: '\\',
-    })),
+    bashDoubleQuotedEscapeParser,
+    bashDoubleQuotedLiteralParser,
+    bashBareDollarParser,
+    bashBareBackslashParser,
 ]);
 // Double quoted string: "..."
 const bashDoubleQuotedParser = createObjectParser({
@@ -124,12 +271,45 @@ const bashLiteralWordPartParser = createObjectParser({
     type: 'literal',
     value: bashUnquotedWordCharsParser,
 });
-// Escape sequence outside quotes
-const bashEscapeParser = promiseCompose(createRegExpParser(/\\./), match => ({
+// Bare {} treated as a literal word (e.g., find -exec cmd {} \;)
+const bashBraceWordPartParser = promiseCompose(createExactSequenceParser('{}'), () => ({
+    type: 'literal',
+    value: '{}',
+}));
+// Bare { treated as a literal word part (e.g., echo {, echo {.})
+// Note: } is NOT included here because it would break brace group closing
+const bashOpenBraceWordPartParser = promiseCompose(createExactSequenceParser('{'), () => ({
     type: 'literal',
-    value: match[0].slice(1),
+    value: '{',
 }));
-// Word part (any part of a word)
+// Bare } treated as a literal word part (e.g., echo }, echo }hello)
+const bashCloseBraceWordPartParser = promiseCompose(createExactSequenceParser('}'), () => ({
+    type: 'literal',
+    value: '}',
+}));
+// Escape sequence outside quotes: backslash followed by any character
+const bashEscapeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\'),
+    createElementParser(),
+]), ([, ch]) => ({ type: 'literal', value: ch }));
+// Word part for use inside ${...} operands (uses literal parser that excludes } from continuation)
+const bashBracedVarWordPartParser = createDisjunctionParser([
+    bashAnsiCQuotedParser,
+    bashSingleQuotedParser,
+    bashDoubleQuotedParser,
+    bashBracedVariableParser,
+    bashArithmeticExpansionParser,
+    bashCommandSubstitutionParser,
+    bashBacktickSubstitutionParser,
+    bashSimpleVariableParser,
+    bashEscapeParser,
+    bashBracedVarLiteralWordPartParser,
+    bashBareDollarParser,
+]);
+const bashBracedVarWordParser = createObjectParser({
+    parts: createNonEmptyArrayParser(bashBracedVarWordPartParser),
+});
+// Word part (any part of a word, } excluded from first position so brace groups work)
 const bashWordPartParser = createDisjunctionParser([
     bashAnsiCQuotedParser,
     bashSingleQuotedParser,
@@ -141,21 +321,46 @@ const bashWordPartParser = createDisjunctionParser([
     bashSimpleVariableParser,
     bashProcessSubstitutionParser,
     bashEscapeParser,
+    bashBraceWordPartParser,
+    bashOpenBraceWordPartParser,
     bashLiteralWordPartParser,
-    // Bare $ not followed by a valid expansion start
-    promiseCompose(createRegExpParser(/\$/), () => ({
-        type: 'literal',
-        value: '$',
-    })),
+    bashBareDollarParser,
+]);
+// Word part including } as a starter (for argument positions where } is not reserved)
+const bashArgWordPartParser = createDisjunctionParser([
+    bashAnsiCQuotedParser,
+    bashSingleQuotedParser,
+    bashDoubleQuotedParser,
+    bashBracedVariableParser,
+    bashArithmeticExpansionParser,
+    bashCommandSubstitutionParser,
+    bashBacktickSubstitutionParser,
+    bashSimpleVariableParser,
+    bashProcessSubstitutionParser,
+    bashEscapeParser,
+    bashBraceWordPartParser,
+    bashOpenBraceWordPartParser,
+    bashCloseBraceWordPartParser,
+    bashLiteralWordPartParser,
+    bashBareDollarParser,
 ]);
 // Word (sequence of word parts)
 export const bashWordParser = createObjectParser({
     parts: createNonEmptyArrayParser(bashWordPartParser),
 });
+// Argument word (allows } as first character)
+const bashArgWordParser = createObjectParser({
+    parts: createNonEmptyArrayParser(bashArgWordPartParser),
+});
 setParserName(bashWordParser, 'bashWordParser');
+// Assignment name: identifier followed by =
+const bashAssignmentNameParser = promiseCompose(createTupleParser([
+    bashIdentifierParser,
+    createExactSequenceParser('='),
+]), ([name]) => name);
 // Assignment: NAME=value or NAME=
 const bashAssignmentParser = createObjectParser({
-    name: promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/), match => match[0].slice(0, -1)),
+    name: bashAssignmentNameParser,
     value: createOptionalParser(bashWordParser),
 });
 // Redirect operators
@@ -169,9 +374,11 @@ const bashRedirectOperatorParser = createDisjunctionParser([
     promiseCompose(createExactSequenceParser('<&'), () => '<&'),
     promiseCompose(createExactSequenceParser('<'), () => '<'),
 ]);
+// File descriptor number
+const bashFdParser = promiseCompose(bashDigitsParser, digits => Number.parseInt(digits, 10));
 // Redirect: [n]op word
 const bashRedirectParser = createObjectParser({
-    fd: createOptionalParser(promiseCompose(createRegExpParser(/[0-9]+/), match => Number.parseInt(match[0], 10))),
+    fd: createOptionalParser(bashFdParser),
     operator: bashRedirectOperatorParser,
     _ws: bashOptionalInlineWhitespaceParser,
     target: bashWordParser,
@@ -181,37 +388,48 @@ const bashWordWithWhitespaceParser = promiseCompose(createTupleParser([
     bashWordParser,
     bashOptionalInlineWhitespaceParser,
 ]), ([word]) => word);
+// Arg word (allows }) with optional trailing whitespace
+const bashArgWordWithWhitespaceParser = promiseCompose(createTupleParser([
+    bashArgWordParser,
+    bashOptionalInlineWhitespaceParser,
+]), ([word]) => word);
 // Redirect with optional trailing whitespace
 const bashRedirectWithWhitespaceParser = promiseCompose(createTupleParser([
     bashRedirectParser,
     bashOptionalInlineWhitespaceParser,
 ]), ([redirect]) => redirect);
-// Word or redirect - for interleaved parsing in simple commands
-const bashWordOrRedirectParser = createDisjunctionParser([
+// Word or redirect for argument position (} allowed)
+const bashArgWordOrRedirectParser = createDisjunctionParser([
     createObjectParser({ type: 'redirect', redirect: bashRedirectWithWhitespaceParser }),
-    createObjectParser({ type: 'word', word: bashWordWithWhitespaceParser }),
+    createObjectParser({ type: 'word', word: bashArgWordWithWhitespaceParser }),
 ]);
 // Simple command: [assignments] [name] [args] [redirects]
-export const bashSimpleCommandParser = promiseCompose(createTupleParser([
-    // Assignments at the start
-    createArrayParser(promiseCompose(createTupleParser([
+export const bashSimpleCommandParser = async (parserContext) => {
+    // Parse assignments at the start
+    const assignmentsParser = createArrayParser(promiseCompose(createTupleParser([
         bashAssignmentParser,
         bashOptionalInlineWhitespaceParser,
-    ]), ([assignment]) => assignment)),
-    // Command name, args, and redirects (interleaved)
-    createArrayParser(bashWordOrRedirectParser),
-]), ([assignments, items]) => {
-    const words = [];
-    const redirects = [];
-    for (const item of items) {
-        if (item.type === 'word') {
-            words.push(item.word);
-        }
-        else {
-            redirects.push(item.redirect);
+    ]), ([assignment]) => assignment));
+    const assignments = await assignmentsParser(parserContext);
+    // Parse leading redirects before command name
+    const leadingRedirectsParser = createArrayParser(bashRedirectWithWhitespaceParser);
+    const leadingRedirects = await leadingRedirectsParser(parserContext);
+    // Parse command name (} not allowed here, so brace group closing works)
+    const name = await createOptionalParser(bashWordWithWhitespaceParser)(parserContext);
+    // Only parse args if we have a command name
+    const args = [];
+    const redirects = [...leadingRedirects];
+    if (name !== undefined) {
+        const argItems = await createArrayParser(bashArgWordOrRedirectParser)(parserContext);
+        for (const item of argItems) {
+            if (item.type === 'word') {
+                args.push(item.word);
+            }
+            else {
+                redirects.push(item.redirect);
+            }
         }
     }
-    const [name, ...args] = words;
     return {
         type: 'simple',
         name,
@@ -219,7 +437,7 @@ export const bashSimpleCommandParser = promiseCompose(createTupleParser([
         redirects,
         assignments,
     };
-});
+};
 setParserName(bashSimpleCommandParser, 'bashSimpleCommandParser');
 // Subshell: ( command )
 const bashSubshellParser = createObjectParser({
@@ -251,7 +469,10 @@ const bashCommandUnitParser = createDisjunctionParser([
 ]);
 setParserName(bashCommandUnitParser, 'bashCommandUnitParser');
 // Single pipe (not ||) - matches | only when not followed by another |
-const bashSinglePipeParser = promiseCompose(createRegExpParser(/\|(?!\|)/), match => match[0]);
+const bashSinglePipeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('|'),
+    createNegativeLookaheadParser(createExactSequenceParser('|')),
+]), () => '|');
 // Pipeline: [!] cmd [| cmd]...
 const bashPipelineParser = promiseCompose(createTupleParser([
     createOptionalParser(promiseCompose(createTupleParser([
@@ -269,13 +490,35 @@ const bashPipelineParser = promiseCompose(createTupleParser([
     commands,
 }));
 setParserName(bashPipelineParser, 'bashPipelineParser');
+// Non-newline character
+const bashNonNewlineCharParser = promiseCompose(createTupleParser([
+    createNegativeLookaheadParser(createExactSequenceParser('\n')),
+    createElementParser(),
+]), ([, ch]) => ch);
+// Comment: # through end of line (not consuming the newline)
+const bashCommentParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('#'),
+    createArrayParser(bashNonNewlineCharParser),
+]), ([hash, chars]) => hash + chars.join(''));
+// Blank line filler: whitespace, newlines, and comments
+const bashBlankLineFillerParser = promiseCompose(createArrayParser(createDisjunctionParser([
+    bashInlineWhitespaceUnitParser,
+    promiseCompose(createExactSequenceParser('\n'), () => '\n'),
+    bashCommentParser,
+])), () => { });
+// Newline separator: consumes a newline plus any following blank lines, comments, and whitespace
+// This allows multi-line scripts with blank lines and mid-script comments
+const bashNewlineSeparatorParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\n'),
+    bashBlankLineFillerParser,
+]), () => '\n');
 // Command list separator
 const bashListSeparatorParser = createDisjunctionParser([
     promiseCompose(createExactSequenceParser('&&'), () => '&&'),
     promiseCompose(createExactSequenceParser('||'), () => '||'),
     promiseCompose(createExactSequenceParser(';'), () => ';'),
     promiseCompose(createExactSequenceParser('&'), () => '&'),
-    promiseCompose(bashNewlineParser, () => '\n'),
+    bashNewlineSeparatorParser,
 ]);
 // Command list: pipeline [sep pipeline]...
 const bashCommandListParser = promiseCompose(createTupleParser([
@@ -323,13 +566,12 @@ setParserName(bashCommandListParser, 'bashCommandListParser');
 // Top-level command parser
 export const bashCommandParser = bashCommandListParser;
 setParserName(bashCommandParser, 'bashCommandParser');
-// Comment: # through end of line
-const bashOptionalCommentParser = createOptionalParser(promiseCompose(createRegExpParser(/#[^\n]*/), match => match[0]));
+// Trailing whitespace/comments/blank lines at end of script
+const bashTrailingWhitespaceAndCommentsParser = promiseCompose(bashBlankLineFillerParser, () => undefined);
 // Script parser (handles leading/trailing whitespace and comments)
 export const bashScriptParser = promiseCompose(createTupleParser([
     bashOptionalInlineWhitespaceParser,
     bashCommandParser,
-    bashOptionalInlineWhitespaceParser,
-    bashOptionalCommentParser,
+    bashTrailingWhitespaceAndCommentsParser,
 ]), ([, command]) => command);
 setParserName(bashScriptParser, 'bashScriptParser');

package/build/bashParser.test.js

@@ -341,3 +341,74 @@ test('if treated as command name', async (t) => {
         t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: 'if' }] });
     }
 });
+test('find -exec with {} placeholder', async (t) => {
+    const result = await runParser(bashScriptParser, 'find . -name "*.tmp" -exec rm {} \\;', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.name.parts[0].type, 'literal');
+    t.is(cmd.name.parts[0].value, 'find');
+    // {} should be parsed as a literal word argument
+    const braceArg = cmd.args[5]; // ., -name, "*.tmp", -exec, rm, {}, \;
+    t.is(braceArg.parts[0].type, 'literal');
+    t.is(braceArg.parts[0].value, '{}');
+});
+test('lone open brace as argument', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo {', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.deepEqual(cmd.args[0], {
+        parts: [{ type: 'literal', value: '{' }],
+    });
+});
+test('close brace mid-word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo}bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('open brace mid-word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo{bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('braces mid-word like brace expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo file.{c,h}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('find -exec with {.} placeholder variant', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo {.}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('lone close brace as argument', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo }', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.deepEqual(cmd.args[0], {
+        parts: [{ type: 'literal', value: '}' }],
+    });
+});
+test('close brace at start of word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo }hello', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('multi-line script with blank lines', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello\n\necho world', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+});
+test('mid-script comment', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello\n# comment\necho world', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+});
+test('nested parentheses in arithmetic expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $((1 + (2 * 3)))', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    const arith = cmd.args[0].parts[0];
+    t.is(arith.type, 'arithmeticExpansion');
+    if (arith.type === 'arithmeticExpansion') {
+        t.is(arith.expression, '1 + (2 * 3)');
+    }
+});

package/build/index.d.ts

@@ -16,6 +16,7 @@ export { createUnionParser, } from './unionParser.js';
 export { createDisjunctionParser, } from './disjunctionParser.js';
 export { createParserAccessorParser, } from './parserAccessorParser.js';
 export { createElementParser, } from './elementParser.js';
+export { createPredicateElementParser, } from './predicateElementParser.js';
 export { createTerminatedArrayParser, } from './terminatedArrayParser.js';
 export { createSliceBoundedParser, } from './sliceBoundedParser.js';
 export { createExactElementParser, } from './exactElementParser.js';

package/build/index.js

@@ -14,6 +14,7 @@ export { createUnionParser, } from './unionParser.js';
 export { createDisjunctionParser, } from './disjunctionParser.js';
 export { createParserAccessorParser, } from './parserAccessorParser.js';
 export { createElementParser, } from './elementParser.js';
+export { createPredicateElementParser, } from './predicateElementParser.js';
 export { createTerminatedArrayParser, } from './terminatedArrayParser.js';
 export { createSliceBoundedParser, } from './sliceBoundedParser.js';
 export { createExactElementParser, } from './exactElementParser.js';

package/build/predicateElementParser.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+export declare const createPredicateElementParser: <Sequence, Element = DeriveSequenceElement<Sequence>>(predicate: (element: Element) => boolean) => Parser<Element, Sequence, Element>;

package/build/predicateElementParser.js

@@ -0,0 +1,10 @@
+import { setParserName } from './parser.js';
+export const createPredicateElementParser = (predicate) => {
+    const predicateElementParser = async (parserContext) => {
+        const element = await parserContext.read(0);
+        parserContext.invariant(predicate(element), 'Element does not match predicate: %s', element);
+        return element;
+    };
+    setParserName(predicateElementParser, `createPredicateElementParser(${predicate.name || 'anonymous'})`);
+    return predicateElementParser;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futpib/parser",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "license": "GPL-3.0-only",