@futpib/parser 1.0.4 → 1.0.7

package/src/bashParser.ts

@@ -1,15 +1,18 @@
 import { type Parser, setParserName } from './parser.js';
-import { createUnionParser } from './unionParser.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';
 import {
 	type BashWord,
 	type BashWordPart,
@@ -17,8 +20,11 @@ import {
 	type BashWordPartSingleQuoted,
 	type BashWordPartDoubleQuoted,
 	type BashWordPartVariable,
+	type BashWordPartVariableBraced,
 	type BashWordPartCommandSubstitution,
 	type BashWordPartBacktickSubstitution,
+	type BashWordPartArithmeticExpansion,
+	type BashWordPartProcessSubstitution,
 	type BashSimpleCommand,
 	type BashSubshell,
 	type BashBraceGroup,
@@ -30,180 +36,495 @@ import {
 	type BashCommand,
 } from './bash.js';
 
-// Whitespace (spaces and tabs, not newlines - those are significant)
+// Character predicates
+function isDigit(ch: string): boolean {
+	return ch >= '0' && ch <= '9';
+}
+
+function isLetter(ch: string): boolean {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+}
+
+function isIdentStart(ch: string): boolean {
+	return isLetter(ch) || ch === '_';
+}
+
+function isIdentChar(ch: string): boolean {
+	return isIdentStart(ch) || isDigit(ch);
+}
+
+// Whitespace (spaces, tabs, and line continuations - not bare newlines which are significant)
+const bashInlineWhitespaceUnitParser: Parser<string, string> = createDisjunctionParser([
+	promiseCompose(createExactSequenceParser(' '), () => ' '),
+	promiseCompose(createExactSequenceParser('\t'), () => '\t'),
+	promiseCompose(createExactSequenceParser('\\\n'), () => '\\\n'),
+]);
+
 const bashInlineWhitespaceParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/[ \t]+/),
-	match => match[0],
+	createNonEmptyArrayParser(bashInlineWhitespaceUnitParser),
+	parts => parts.join(''),
 );
 
 const bashOptionalInlineWhitespaceParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/[ \t]*/),
-	match => match[0],
+	createArrayParser(bashInlineWhitespaceUnitParser),
+	parts => parts.join(''),
 );
 
-// Newline
-const bashNewlineParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/\n/),
-	match => match[0],
+// Word characters (unquoted, no special chars)
+// 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: Parser<unknown, string> = createDisjunctionParser(
+	[...' \t\n|&;<>()$`"\'\\'].map(ch => createExactSequenceParser(ch)),
+);
+
+const bashWordStartExcludeParser: Parser<unknown, string> = createDisjunctionParser([
+	bashSpecialCharParser,
+	createExactSequenceParser('{'),
+	createExactSequenceParser('}'),
+	createExactSequenceParser('#'),
+]);
+
+const bashUnquotedWordStartCharParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createNegativeLookaheadParser(bashWordStartExcludeParser),
+		createElementParser<string>(),
+	]),
+	([, ch]) => ch,
+);
+
+const bashUnquotedWordContinueCharParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createNegativeLookaheadParser(bashSpecialCharParser),
+		createElementParser<string>(),
+	]),
+	([, ch]) => ch,
 );
 
-// Word characters (unquoted, no special chars)
-// Note: {} are excluded so brace groups are parsed correctly
 const bashUnquotedWordCharsParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#]+/),
-	match => match[0],
+	createTupleParser([
+		bashUnquotedWordStartCharParser,
+		createArrayParser(bashUnquotedWordContinueCharParser),
+	]),
+	([first, rest]) => first + rest.join(''),
 );
 
+// Consume characters until a given terminator, returning the accumulated string
+function createUntilCharParser(terminator: string): Parser<string, string> {
+	return promiseCompose(
+		createArrayParser(promiseCompose(
+			createTupleParser([
+				createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+				createElementParser<string>(),
+			]),
+			([, ch]) => ch,
+		)),
+		chars => chars.join(''),
+	);
+}
+
 // Single quoted string: '...'
-const bashSingleQuotedParser: Parser<BashWordPartSingleQuoted, string> = promiseCompose(
+const bashSingleQuotedParser: Parser<BashWordPartSingleQuoted, string> = createObjectParser({
+	type: 'singleQuoted' as const,
+	_open: createExactSequenceParser("'"),
+	value: createUntilCharParser("'"),
+	_close: createExactSequenceParser("'"),
+});
+
+// Variable name: identifiers, positional params ($0, $1...), or special params ($@, $*, $#, $?, $$, $!, $-)
+const bashSpecialParams = new Set(['@', '*', '#', '?', '$', '!', '-']);
+
+const bashIdentifierParser: Parser<string, string> = promiseCompose(
 	createTupleParser([
-		createExactSequenceParser("'"),
-		promiseCompose(
-			createRegExpParser(/[^']*/),
-			match => match[0],
-		),
-		createExactSequenceParser("'"),
+		createPredicateElementParser<string>(isIdentStart),
+		createArrayParser(createPredicateElementParser<string>(isIdentChar)),
 	]),
-	([, value]) => ({
-		type: 'singleQuoted' as const,
-		value,
-	}),
+	([first, rest]) => first + rest.join(''),
+);
+
+const bashDigitsParser: Parser<string, string> = promiseCompose(
+	createNonEmptyArrayParser(createPredicateElementParser<string>(isDigit)),
+	chars => chars.join(''),
 );
 
-// Variable name
-const bashVariableNameParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*|[0-9]+|[@*#?$!-]/),
-	match => match[0],
+const bashSpecialParamParser: Parser<string, string> = createPredicateElementParser<string>(
+	ch => bashSpecialParams.has(ch),
 );
 
+const bashVariableNameParser: Parser<string, string> = createDisjunctionParser([
+	bashIdentifierParser,
+	bashDigitsParser,
+	bashSpecialParamParser,
+]);
+
 // Simple variable: $var
-const bashSimpleVariableParser: Parser<BashWordPartVariable, string> = promiseCompose(
+const bashSimpleVariableParser: Parser<BashWordPartVariable, string> = createObjectParser({
+	type: 'variable' as const,
+	_dollar: createExactSequenceParser('$'),
+	name: bashVariableNameParser,
+});
+
+// Command substitution: $(...)
+const bashCommandSubstitutionParser: Parser<BashWordPartCommandSubstitution, string> = createObjectParser({
+	type: 'commandSubstitution' as const,
+	_open: createExactSequenceParser('$('),
+	_ws1: bashOptionalInlineWhitespaceParser,
+	command: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser(')'),
+});
+
+// Backtick substitution: `...`
+const bashBacktickSubstitutionParser: Parser<BashWordPartBacktickSubstitution, string> = createObjectParser({
+	type: 'backtickSubstitution' as const,
+	_open: createExactSequenceParser('`'),
+	command: createParserAccessorParser(() => bashCommandParser),
+	_close: createExactSequenceParser('`'),
+});
+
+// Word characters for use inside ${...} operands (} excluded from continuation to not consume the closing brace)
+const bashBracedVarContinueExcludeParser: Parser<unknown, string> = createDisjunctionParser([
+	bashSpecialCharParser,
+	createExactSequenceParser('{'),
+	createExactSequenceParser('}'),
+]);
+
+const bashBracedVarUnquotedWordCharsParser: Parser<string, string> = promiseCompose(
 	createTupleParser([
-		createExactSequenceParser('$'),
-		bashVariableNameParser,
+		bashUnquotedWordStartCharParser,
+		createArrayParser(promiseCompose(
+			createTupleParser([
+				createNegativeLookaheadParser(bashBracedVarContinueExcludeParser),
+				createElementParser<string>(),
+			]),
+			([, ch]) => ch,
+		)),
 	]),
-	([, name]) => ({
-		type: 'variable' as const,
-		name,
-	}),
+	([first, rest]) => first + rest.join(''),
 );
 
-// Command substitution: $(...)
-const bashCommandSubstitutionParser: Parser<BashWordPartCommandSubstitution, string> = promiseCompose(
+const bashBracedVarLiteralWordPartParser: Parser<BashWordPartLiteral, string> = createObjectParser({
+	type: 'literal' as const,
+	value: bashBracedVarUnquotedWordCharsParser,
+});
+
+// Braced variable expansion: ${VAR} or ${VAR:-default}
+const bashBracedVariableParser: Parser<BashWordPartVariableBraced, string> = createObjectParser({
+	type: 'variableBraced' as const,
+	_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: Parser<string, string> = 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: Parser<BashWordPartArithmeticExpansion, string> = createObjectParser({
+	type: 'arithmeticExpansion' as const,
+	_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: Parser<string, string> = createDisjunctionParser([
+	// Backslash escape: \x (any char after backslash)
+	promiseCompose(
+		createTupleParser([
+			createExactSequenceParser('\\'),
+			createElementParser<string>(),
+		]),
+		([bs, ch]) => bs + ch,
+	),
+	// Any character that isn't ' (and isn't \ which is handled above)
+	promiseCompose(
+		createTupleParser([
+			createNegativeLookaheadParser(createExactSequenceParser("'")),
+			createElementParser<string>(),
+		]),
+		([, ch]) => ch,
+	),
+]);
+
+const bashAnsiCContentParser: Parser<string, string> = promiseCompose(
+	createArrayParser(bashAnsiCContentUnitParser),
+	parts => parts.join(''),
+);
+
+const bashAnsiCQuotedParser: Parser<BashWordPartSingleQuoted, string> = createObjectParser({
+	type: 'singleQuoted' as const,
+	_prefix: createExactSequenceParser('$'),
+	_open: createExactSequenceParser("'"),
+	value: bashAnsiCContentParser,
+	_close: createExactSequenceParser("'"),
+});
+
+// Process substitution: <(cmd) or >(cmd)
+const bashProcessSubstitutionDirectionParser: Parser<'<' | '>', string> = promiseCompose(
 	createTupleParser([
-		createExactSequenceParser('$('),
-		bashOptionalInlineWhitespaceParser,
-		createParserAccessorParser(() => bashCommandParser),
-		bashOptionalInlineWhitespaceParser,
-		createExactSequenceParser(')'),
+		createDisjunctionParser([
+			createExactSequenceParser('<' as const),
+			createExactSequenceParser('>' as const),
+		]),
+		createLookaheadParser(createExactSequenceParser('(')),
 	]),
-	([, , command]) => ({
-		type: 'commandSubstitution' as const,
-		command,
-	}),
+	([dir]) => dir as '<' | '>',
 );
 
-// Backtick substitution: `...`
-const bashBacktickSubstitutionParser: Parser<BashWordPartBacktickSubstitution, string> = promiseCompose(
+const bashProcessSubstitutionParser: Parser<BashWordPartProcessSubstitution, string> = createObjectParser({
+	type: 'processSubstitution' as const,
+	direction: bashProcessSubstitutionDirectionParser,
+	_open: createExactSequenceParser('('),
+	_ws1: bashOptionalInlineWhitespaceParser,
+	command: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser(')'),
+});
+
+// Escape sequences in double quotes: \\ \$ \` \" \! \newline
+const bashDoubleQuotedEscapeCharParser: Parser<string, string> = createDisjunctionParser([
+	createExactSequenceParser('\\'),
+	createExactSequenceParser('$'),
+	createExactSequenceParser('`'),
+	createExactSequenceParser('"'),
+	createExactSequenceParser('!'),
+	createExactSequenceParser('\n'),
+]);
+
+const bashDoubleQuotedEscapeParser: Parser<BashWordPartLiteral, string> = promiseCompose(
 	createTupleParser([
-		createExactSequenceParser('`'),
-		createParserAccessorParser(() => bashCommandParser),
-		createExactSequenceParser('`'),
+		createExactSequenceParser('\\'),
+		bashDoubleQuotedEscapeCharParser,
 	]),
-	([, command]) => ({
-		type: 'backtickSubstitution' as const,
-		command,
-	}),
+	([, ch]) => ({ type: 'literal' as const, value: ch }),
+);
+
+// Literal text inside double quotes (no special chars)
+const bashDoubleQuotedLiteralCharParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createNegativeLookaheadParser(createDisjunctionParser([
+			createExactSequenceParser('$'),
+			createExactSequenceParser('`'),
+			createExactSequenceParser('"'),
+			createExactSequenceParser('\\'),
+		])),
+		createElementParser<string>(),
+	]),
+	([, ch]) => ch,
+);
+
+const bashDoubleQuotedLiteralParser: Parser<BashWordPartLiteral, string> = promiseCompose(
+	createNonEmptyArrayParser(bashDoubleQuotedLiteralCharParser),
+	chars => ({ type: 'literal' as const, value: chars.join('') }),
+);
+
+// Bare $ not followed by a valid expansion start
+const bashBareDollarParser: Parser<BashWordPartLiteral, string> = promiseCompose(
+	createExactSequenceParser('$'),
+	() => ({ type: 'literal' as const, value: '$' }),
+);
+
+// Bare \ not followed by a recognized escape character
+const bashBareBackslashParser: Parser<BashWordPartLiteral, string> = promiseCompose(
+	createExactSequenceParser('\\'),
+	() => ({ type: 'literal' as const, value: '\\' }),
 );
 
 // Double quoted string parts (inside "...")
 const bashDoubleQuotedPartParser: Parser<BashWordPart, string> = createDisjunctionParser([
+	bashBracedVariableParser,
+	bashArithmeticExpansionParser,
 	bashSimpleVariableParser,
 	bashCommandSubstitutionParser,
 	bashBacktickSubstitutionParser,
-	// Escape sequences in double quotes
-	promiseCompose(
-		createRegExpParser(/\\[\\$`"!\n]/),
-		match => ({
-			type: 'literal' as const,
-			value: match[0].slice(1),
-		}),
-	),
-	// Literal text (no special chars)
-	promiseCompose(
-		createRegExpParser(/[^$`"\\]+/),
-		match => ({
-			type: 'literal' as const,
-			value: match[0],
-		}),
-	),
+	bashDoubleQuotedEscapeParser,
+	bashDoubleQuotedLiteralParser,
+	bashBareDollarParser,
+	bashBareBackslashParser,
 ]);
 
 // Double quoted string: "..."
-const bashDoubleQuotedParser: Parser<BashWordPartDoubleQuoted, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('"'),
-		createArrayParser(bashDoubleQuotedPartParser),
-		createExactSequenceParser('"'),
-	]),
-	([, parts]) => ({
-		type: 'doubleQuoted' as const,
-		parts,
+const bashDoubleQuotedParser: Parser<BashWordPartDoubleQuoted, string> = createObjectParser({
+	type: 'doubleQuoted' as const,
+	_open: createExactSequenceParser('"'),
+	parts: createArrayParser(bashDoubleQuotedPartParser),
+	_close: createExactSequenceParser('"'),
+});
+
+// Literal word part (unquoted)
+const bashLiteralWordPartParser: Parser<BashWordPartLiteral, string> = createObjectParser({
+	type: 'literal' as const,
+	value: bashUnquotedWordCharsParser,
+});
+
+// Bare {} treated as a literal word (e.g., find -exec cmd {} \;)
+const bashBraceWordPartParser: Parser<BashWordPartLiteral, string> = promiseCompose(
+	createExactSequenceParser('{}'),
+	() => ({
+		type: 'literal' as const,
+		value: '{}',
 	}),
 );
 
-// Literal word part (unquoted)
-const bashLiteralWordPartParser: Parser<BashWordPartLiteral, string> = promiseCompose(
-	bashUnquotedWordCharsParser,
-	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: Parser<BashWordPartLiteral, string> = promiseCompose(
+	createExactSequenceParser('{'),
+	() => ({
 		type: 'literal' as const,
-		value,
+		value: '{',
 	}),
 );
 
-// Escape sequence outside quotes
-const bashEscapeParser: Parser<BashWordPartLiteral, string> = promiseCompose(
-	createRegExpParser(/\\./),
-	match => ({
+// Bare } treated as a literal word part (e.g., echo }, echo }hello)
+const bashCloseBraceWordPartParser: Parser<BashWordPartLiteral, string> = promiseCompose(
+	createExactSequenceParser('}'),
+	() => ({
 		type: 'literal' as const,
-		value: match[0].slice(1),
+		value: '}',
 	}),
 );
 
-// Word part (any part of a word)
+// Escape sequence outside quotes: backslash followed by any character
+const bashEscapeParser: Parser<BashWordPartLiteral, string> = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser('\\'),
+		createElementParser<string>(),
+	]),
+	([, ch]) => ({ type: 'literal' as const, value: ch }),
+);
+
+// Word part for use inside ${...} operands (uses literal parser that excludes } from continuation)
+const bashBracedVarWordPartParser: Parser<BashWordPart, string> = createDisjunctionParser([
+	bashAnsiCQuotedParser,
+	bashSingleQuotedParser,
+	bashDoubleQuotedParser,
+	bashBracedVariableParser,
+	bashArithmeticExpansionParser,
+	bashCommandSubstitutionParser,
+	bashBacktickSubstitutionParser,
+	bashSimpleVariableParser,
+	bashEscapeParser,
+	bashBracedVarLiteralWordPartParser,
+	bashBareDollarParser,
+]);
+
+const bashBracedVarWordParser: Parser<BashWord, string> = createObjectParser({
+	parts: createNonEmptyArrayParser(bashBracedVarWordPartParser),
+});
+
+// Word part (any part of a word, } excluded from first position so brace groups work)
 const bashWordPartParser: Parser<BashWordPart, string> = 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: Parser<BashWordPart, string> = createDisjunctionParser([
+	bashAnsiCQuotedParser,
+	bashSingleQuotedParser,
+	bashDoubleQuotedParser,
+	bashBracedVariableParser,
+	bashArithmeticExpansionParser,
+	bashCommandSubstitutionParser,
+	bashBacktickSubstitutionParser,
+	bashSimpleVariableParser,
+	bashProcessSubstitutionParser,
+	bashEscapeParser,
+	bashBraceWordPartParser,
+	bashOpenBraceWordPartParser,
+	bashCloseBraceWordPartParser,
+	bashLiteralWordPartParser,
+	bashBareDollarParser,
 ]);
 
 // Word (sequence of word parts)
-export const bashWordParser: Parser<BashWord, string> = promiseCompose(
-	createNonEmptyArrayParser(bashWordPartParser),
-	parts => ({ parts }),
-);
+export const bashWordParser: Parser<BashWord, string> = createObjectParser({
+	parts: createNonEmptyArrayParser(bashWordPartParser),
+});
+
+// Argument word (allows } as first character)
+const bashArgWordParser: Parser<BashWord, string> = createObjectParser({
+	parts: createNonEmptyArrayParser(bashArgWordPartParser),
+});
 
 setParserName(bashWordParser, 'bashWordParser');
 
-// Assignment: NAME=value or NAME=
-const bashAssignmentParser: Parser<BashAssignment, string> = promiseCompose(
+// Assignment name: identifier followed by =
+const bashAssignmentNameParser: Parser<string, string> = promiseCompose(
 	createTupleParser([
-		promiseCompose(
-			createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/),
-			match => match[0].slice(0, -1),
-		),
-		createOptionalParser(bashWordParser),
+		bashIdentifierParser,
+		createExactSequenceParser('='),
 	]),
-	([name, value]) => ({
-		name,
-		value: value ?? undefined,
-	}),
+	([name]) => name,
 );
 
+// Assignment: NAME=value or NAME=
+const bashAssignmentParser: Parser<BashAssignment, string> = createObjectParser({
+	name: bashAssignmentNameParser,
+	value: createOptionalParser(bashWordParser),
+});
+
 // Redirect operators
 const bashRedirectOperatorParser: Parser<BashRedirect['operator'], string> = createDisjunctionParser([
 	promiseCompose(createExactSequenceParser('>>'), () => '>>' as const),
@@ -216,28 +537,33 @@ const bashRedirectOperatorParser: Parser<BashRedirect['operator'], string> = cre
 	promiseCompose(createExactSequenceParser('<'), () => '<' as const),
 ]);
 
+// File descriptor number
+const bashFdParser: Parser<number, string> = promiseCompose(
+	bashDigitsParser,
+	digits => Number.parseInt(digits, 10),
+);
+
 // Redirect: [n]op word
-const bashRedirectParser: Parser<BashRedirect, string> = promiseCompose(
+const bashRedirectParser: Parser<BashRedirect, string> = createObjectParser({
+	fd: createOptionalParser(bashFdParser),
+	operator: bashRedirectOperatorParser,
+	_ws: bashOptionalInlineWhitespaceParser,
+	target: bashWordParser,
+});
+
+// Word with optional trailing whitespace - for use in arrays
+const bashWordWithWhitespaceParser: Parser<BashWord, string> = promiseCompose(
 	createTupleParser([
-		createOptionalParser(promiseCompose(
-			createRegExpParser(/[0-9]+/),
-			match => Number.parseInt(match[0], 10),
-		)),
-		bashRedirectOperatorParser,
-		bashOptionalInlineWhitespaceParser,
 		bashWordParser,
+		bashOptionalInlineWhitespaceParser,
 	]),
-	([fd, operator, , target]) => ({
-		fd: fd ?? undefined,
-		operator,
-		target,
-	}),
+	([word]) => word,
 );
 
-// Word with optional trailing whitespace - for use in arrays
-const bashWordWithWhitespaceParser: Parser<BashWord, string> = promiseCompose(
+// Arg word (allows }) with optional trailing whitespace
+const bashArgWordWithWhitespaceParser: Parser<BashWord, string> = promiseCompose(
 	createTupleParser([
-		bashWordParser,
+		bashArgWordParser,
 		bashOptionalInlineWhitespaceParser,
 	]),
 	([word]) => word,
@@ -252,85 +578,80 @@ const bashRedirectWithWhitespaceParser: Parser<BashRedirect, string> = promiseCo
 	([redirect]) => redirect,
 );
 
-// Word or redirect - for interleaved parsing in simple commands
-const bashWordOrRedirectParser: Parser<{ type: 'word'; word: BashWord } | { type: 'redirect'; redirect: BashRedirect }, string> = createDisjunctionParser([
-	promiseCompose(bashRedirectWithWhitespaceParser, redirect => ({ type: 'redirect' as const, redirect })),
-	promiseCompose(bashWordWithWhitespaceParser, word => ({ type: 'word' as const, word })),
+// Word or redirect for argument position (} allowed)
+const bashArgWordOrRedirectParser: Parser<{ type: 'word'; word: BashWord } | { type: 'redirect'; redirect: BashRedirect }, string> = createDisjunctionParser([
+	createObjectParser({ type: 'redirect' as const, redirect: bashRedirectWithWhitespaceParser }),
+	createObjectParser({ type: 'word' as const, word: bashArgWordWithWhitespaceParser }),
 ]);
 
 // Simple command: [assignments] [name] [args] [redirects]
-export const bashSimpleCommandParser: Parser<BashSimpleCommand, string> = promiseCompose(
-	createTupleParser([
-		// Assignments at the start
-		createArrayParser(promiseCompose(
-			createTupleParser([
-				bashAssignmentParser,
-				bashOptionalInlineWhitespaceParser,
-			]),
-			([assignment]) => assignment,
-		)),
-		// Command name, args, and redirects (interleaved)
-		createArrayParser(bashWordOrRedirectParser),
-	]),
-	([assignments, items]) => {
-		const words: BashWord[] = [];
-		const redirects: BashRedirect[] = [];
-
-		for (const item of items) {
+export const bashSimpleCommandParser: Parser<BashSimpleCommand, string> = async (parserContext) => {
+	// Parse assignments at the start
+	const assignmentsParser = createArrayParser(promiseCompose(
+		createTupleParser([
+			bashAssignmentParser,
+			bashOptionalInlineWhitespaceParser,
+		]),
+		([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: BashWord[] = [];
+	const redirects: BashRedirect[] = [...leadingRedirects];
+
+	if (name !== undefined) {
+		const argItems = await createArrayParser(bashArgWordOrRedirectParser)(parserContext);
+		for (const item of argItems) {
 			if (item.type === 'word') {
-				words.push(item.word);
+				args.push(item.word);
 			} else {
 				redirects.push(item.redirect);
 			}
 		}
+	}
 
-		const [name, ...args] = words;
-
-		return {
-			type: 'simple' as const,
-			name,
-			args,
-			redirects,
-			assignments,
-		};
-	},
-);
+	return {
+		type: 'simple' as const,
+		name,
+		args,
+		redirects,
+		assignments,
+	};
+};
 
 setParserName(bashSimpleCommandParser, 'bashSimpleCommandParser');
 
 // Subshell: ( command )
-const bashSubshellParser: Parser<BashSubshell, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('('),
-		bashOptionalInlineWhitespaceParser,
-		createParserAccessorParser(() => bashCommandParser),
-		bashOptionalInlineWhitespaceParser,
-		createExactSequenceParser(')'),
-	]),
-	([, , body]) => ({
-		type: 'subshell' as const,
-		body,
-	}),
-);
+const bashSubshellParser: Parser<BashSubshell, string> = createObjectParser({
+	type: 'subshell' as const,
+	_open: createExactSequenceParser('('),
+	_ws1: bashOptionalInlineWhitespaceParser,
+	body: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser(')'),
+});
 
 setParserName(bashSubshellParser, 'bashSubshellParser');
 
 // Brace group: { command; }
-const bashBraceGroupParser: Parser<BashBraceGroup, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('{'),
-		bashInlineWhitespaceParser,
-		createParserAccessorParser(() => bashCommandParser),
-		bashOptionalInlineWhitespaceParser,
-		createOptionalParser(createExactSequenceParser(';')),
-		bashOptionalInlineWhitespaceParser,
-		createExactSequenceParser('}'),
-	]),
-	([, , body]) => ({
-		type: 'braceGroup' as const,
-		body,
-	}),
-);
+const bashBraceGroupParser: Parser<BashBraceGroup, string> = createObjectParser({
+	type: 'braceGroup' as const,
+	_open: createExactSequenceParser('{'),
+	_ws1: bashInlineWhitespaceParser,
+	body: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_semi: createOptionalParser(createExactSequenceParser(';')),
+	_ws3: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser('}'),
+});
 
 setParserName(bashBraceGroupParser, 'bashBraceGroupParser');
 
@@ -345,8 +666,11 @@ setParserName(bashCommandUnitParser, 'bashCommandUnitParser');
 
 // Single pipe (not ||) - matches | only when not followed by another |
 const bashSinglePipeParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/\|(?!\|)/),
-	match => match[0],
+	createTupleParser([
+		createExactSequenceParser('|'),
+		createNegativeLookaheadParser(createExactSequenceParser('|')),
+	]),
+	() => '|',
 );
 
 // Pipeline: [!] cmd [| cmd]...
@@ -377,28 +701,63 @@ const bashPipelineParser: Parser<BashPipeline, string> = promiseCompose(
 
 setParserName(bashPipelineParser, 'bashPipelineParser');
 
+// Non-newline character
+const bashNonNewlineCharParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createNegativeLookaheadParser(createExactSequenceParser('\n')),
+		createElementParser<string>(),
+	]),
+	([, ch]) => ch,
+);
+
+// Comment: # through end of line (not consuming the newline)
+const bashCommentParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser('#'),
+		createArrayParser(bashNonNewlineCharParser),
+	]),
+	([hash, chars]) => hash + chars.join(''),
+);
+
+// Blank line filler: whitespace, newlines, and comments
+const bashBlankLineFillerParser: Parser<void, string> = 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: Parser<'\n', string> = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser('\n'),
+		bashBlankLineFillerParser,
+	]),
+	() => '\n' as const,
+);
+
 // Command list separator
 const bashListSeparatorParser: Parser<'&&' | '||' | ';' | '&' | '\n', string> = createDisjunctionParser([
 	promiseCompose(createExactSequenceParser('&&'), () => '&&' as const),
 	promiseCompose(createExactSequenceParser('||'), () => '||' as const),
 	promiseCompose(createExactSequenceParser(';'), () => ';' as const),
 	promiseCompose(createExactSequenceParser('&'), () => '&' as const),
-	promiseCompose(bashNewlineParser, () => '\n' as const),
+	bashNewlineSeparatorParser,
 ]);
 
 // Command list: pipeline [sep pipeline]...
 const bashCommandListParser: Parser<BashCommandList, string> = 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,
@@ -448,12 +807,18 @@ export const bashCommandParser: Parser<BashCommand, string> = bashCommandListPar
 
 setParserName(bashCommandParser, 'bashCommandParser');
 
-// Script parser (handles leading/trailing whitespace)
+// Trailing whitespace/comments/blank lines at end of script
+const bashTrailingWhitespaceAndCommentsParser: Parser<undefined, string> = promiseCompose(
+	bashBlankLineFillerParser,
+	() => undefined,
+);
+
+// Script parser (handles leading/trailing whitespace and comments)
 export const bashScriptParser: Parser<BashCommand, string> = promiseCompose(
 	createTupleParser([
 		bashOptionalInlineWhitespaceParser,
 		bashCommandParser,
-		bashOptionalInlineWhitespaceParser,
+		bashTrailingWhitespaceAndCommentsParser,
 	]),
 	([, command]) => command,
 );