@futpib/parser 1.0.4 → 1.0.7

package/build/bashParser.js

@@ -1,117 +1,368 @@
 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';
-// Whitespace (spaces and tabs, not newlines - those are significant)
-const bashInlineWhitespaceParser = promiseCompose(createRegExpParser(/[ \t]+/), match => match[0]);
-const bashOptionalInlineWhitespaceParser = promiseCompose(createRegExpParser(/[ \t]*/), match => match[0]);
-// Newline
-const bashNewlineParser = promiseCompose(createRegExpParser(/\n/), match => match[0]);
+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 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
-const bashUnquotedWordCharsParser = promiseCompose(createRegExpParser(/[^\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 = promiseCompose(createTupleParser([
-    createExactSequenceParser("'"),
-    promiseCompose(createRegExpParser(/[^']*/), match => match[0]),
-    createExactSequenceParser("'"),
-]), ([, value]) => ({
+const bashSingleQuotedParser = createObjectParser({
     type: 'singleQuoted',
-    value,
-}));
-// Variable name
-const bashVariableNameParser = promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*|[0-9]+|[@*#?$!-]/), match => match[0]);
+    _open: createExactSequenceParser("'"),
+    value: createUntilCharParser("'"),
+    _close: createExactSequenceParser("'"),
+});
+// 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 = promiseCompose(createTupleParser([
-    createExactSequenceParser('$'),
-    bashVariableNameParser,
-]), ([, name]) => ({
+const bashSimpleVariableParser = createObjectParser({
     type: 'variable',
-    name,
-}));
+    _dollar: createExactSequenceParser('$'),
+    name: bashVariableNameParser,
+});
 // Command substitution: $(...)
-const bashCommandSubstitutionParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('$('),
-    bashOptionalInlineWhitespaceParser,
-    createParserAccessorParser(() => bashCommandParser),
-    bashOptionalInlineWhitespaceParser,
-    createExactSequenceParser(')'),
-]), ([, , command]) => ({
+const bashCommandSubstitutionParser = createObjectParser({
     type: 'commandSubstitution',
-    command,
-}));
+    _open: createExactSequenceParser('$('),
+    _ws1: bashOptionalInlineWhitespaceParser,
+    command: createParserAccessorParser(() => bashCommandParser),
+    _ws2: bashOptionalInlineWhitespaceParser,
+    _close: createExactSequenceParser(')'),
+});
 // Backtick substitution: `...`
-const bashBacktickSubstitutionParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('`'),
-    createParserAccessorParser(() => bashCommandParser),
-    createExactSequenceParser('`'),
-]), ([, command]) => ({
+const bashBacktickSubstitutionParser = createObjectParser({
     type: 'backtickSubstitution',
-    command,
-}));
+    _open: createExactSequenceParser('`'),
+    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(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)) - 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: bashArithmeticExpressionParser,
+    _close: createExactSequenceParser('))'),
+});
+// 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: 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: 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,
+    bashArithmeticExpansionParser,
     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],
-    })),
+    bashDoubleQuotedEscapeParser,
+    bashDoubleQuotedLiteralParser,
+    bashBareDollarParser,
+    bashBareBackslashParser,
 ]);
 // Double quoted string: "..."
-const bashDoubleQuotedParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('"'),
-    createArrayParser(bashDoubleQuotedPartParser),
-    createExactSequenceParser('"'),
-]), ([, parts]) => ({
+const bashDoubleQuotedParser = createObjectParser({
     type: 'doubleQuoted',
-    parts,
-}));
+    _open: createExactSequenceParser('"'),
+    parts: createArrayParser(bashDoubleQuotedPartParser),
+    _close: createExactSequenceParser('"'),
+});
 // Literal word part (unquoted)
-const bashLiteralWordPartParser = promiseCompose(bashUnquotedWordCharsParser, value => ({
+const bashLiteralWordPartParser = createObjectParser({
+    type: 'literal',
+    value: bashUnquotedWordCharsParser,
+});
+// Bare {} treated as a literal word (e.g., find -exec cmd {} \;)
+const bashBraceWordPartParser = promiseCompose(createExactSequenceParser('{}'), () => ({
     type: 'literal',
-    value,
+    value: '{}',
 }));
-// Escape sequence outside quotes
-const bashEscapeParser = promiseCompose(createRegExpParser(/\\./), match => ({
+// 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,
+    bashDoubleQuotedParser,
+    bashBracedVariableParser,
+    bashArithmeticExpansionParser,
+    bashCommandSubstitutionParser,
+    bashBacktickSubstitutionParser,
+    bashSimpleVariableParser,
+    bashProcessSubstitutionParser,
+    bashEscapeParser,
+    bashBraceWordPartParser,
+    bashOpenBraceWordPartParser,
+    bashLiteralWordPartParser,
+    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 = promiseCompose(createNonEmptyArrayParser(bashWordPartParser), parts => ({ 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 = promiseCompose(createTupleParser([
-    promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/), match => match[0].slice(0, -1)),
-    createOptionalParser(bashWordParser),
-]), ([name, value]) => ({
-    name,
-    value: value ?? undefined,
-}));
+const bashAssignmentParser = createObjectParser({
+    name: bashAssignmentNameParser,
+    value: createOptionalParser(bashWordParser),
+});
 // Redirect operators
 const bashRedirectOperatorParser = createDisjunctionParser([
     promiseCompose(createExactSequenceParser('>>'), () => '>>'),
@@ -123,53 +374,62 @@ 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 = promiseCompose(createTupleParser([
-    createOptionalParser(promiseCompose(createRegExpParser(/[0-9]+/), match => Number.parseInt(match[0], 10))),
-    bashRedirectOperatorParser,
-    bashOptionalInlineWhitespaceParser,
-    bashWordParser,
-]), ([fd, operator, , target]) => ({
-    fd: fd ?? undefined,
-    operator,
-    target,
-}));
+const bashRedirectParser = createObjectParser({
+    fd: createOptionalParser(bashFdParser),
+    operator: bashRedirectOperatorParser,
+    _ws: bashOptionalInlineWhitespaceParser,
+    target: bashWordParser,
+});
 // Word with optional trailing whitespace - for use in arrays
 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([
-    promiseCompose(bashRedirectWithWhitespaceParser, redirect => ({ type: 'redirect', redirect })),
-    promiseCompose(bashWordWithWhitespaceParser, word => ({ type: 'word', word })),
+// Word or redirect for argument position (} allowed)
+const bashArgWordOrRedirectParser = createDisjunctionParser([
+    createObjectParser({ type: 'redirect', redirect: bashRedirectWithWhitespaceParser }),
+    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,
@@ -177,33 +437,29 @@ export const bashSimpleCommandParser = promiseCompose(createTupleParser([
         redirects,
         assignments,
     };
-});
+};
 setParserName(bashSimpleCommandParser, 'bashSimpleCommandParser');
 // Subshell: ( command )
-const bashSubshellParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('('),
-    bashOptionalInlineWhitespaceParser,
-    createParserAccessorParser(() => bashCommandParser),
-    bashOptionalInlineWhitespaceParser,
-    createExactSequenceParser(')'),
-]), ([, , body]) => ({
+const bashSubshellParser = createObjectParser({
     type: 'subshell',
-    body,
-}));
+    _open: createExactSequenceParser('('),
+    _ws1: bashOptionalInlineWhitespaceParser,
+    body: createParserAccessorParser(() => bashCommandParser),
+    _ws2: bashOptionalInlineWhitespaceParser,
+    _close: createExactSequenceParser(')'),
+});
 setParserName(bashSubshellParser, 'bashSubshellParser');
 // Brace group: { command; }
-const bashBraceGroupParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('{'),
-    bashInlineWhitespaceParser,
-    createParserAccessorParser(() => bashCommandParser),
-    bashOptionalInlineWhitespaceParser,
-    createOptionalParser(createExactSequenceParser(';')),
-    bashOptionalInlineWhitespaceParser,
-    createExactSequenceParser('}'),
-]), ([, , body]) => ({
+const bashBraceGroupParser = createObjectParser({
     type: 'braceGroup',
-    body,
-}));
+    _open: createExactSequenceParser('{'),
+    _ws1: bashInlineWhitespaceParser,
+    body: createParserAccessorParser(() => bashCommandParser),
+    _ws2: bashOptionalInlineWhitespaceParser,
+    _semi: createOptionalParser(createExactSequenceParser(';')),
+    _ws3: bashOptionalInlineWhitespaceParser,
+    _close: createExactSequenceParser('}'),
+});
 setParserName(bashBraceGroupParser, 'bashBraceGroupParser');
 // Command unit: simple command, subshell, or brace group
 const bashCommandUnitParser = createDisjunctionParser([
@@ -213,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([
@@ -231,23 +490,45 @@ 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([
     bashPipelineParser,
-    createArrayParser(promiseCompose(createTupleParser([
-        bashOptionalInlineWhitespaceParser,
-        bashListSeparatorParser,
-        bashOptionalInlineWhitespaceParser,
-        bashPipelineParser,
-    ]), ([, separator, , pipeline]) => ({ separator, pipeline }))),
+    createArrayParser(createObjectParser({
+        _ws1: bashOptionalInlineWhitespaceParser,
+        separator: bashListSeparatorParser,
+        _ws2: bashOptionalInlineWhitespaceParser,
+        pipeline: bashPipelineParser,
+    })),
     createOptionalParser(promiseCompose(createTupleParser([
         bashOptionalInlineWhitespaceParser,
         bashListSeparatorParser,
@@ -285,10 +566,12 @@ setParserName(bashCommandListParser, 'bashCommandListParser');
 // Top-level command parser
 export const bashCommandParser = bashCommandListParser;
 setParserName(bashCommandParser, 'bashCommandParser');
-// Script parser (handles leading/trailing whitespace)
+// 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,
+    bashTrailingWhitespaceAndCommentsParser,
 ]), ([, command]) => command);
 setParserName(bashScriptParser, 'bashScriptParser');