@futpib/parser 1.0.4 → 1.0.6

package/build/bashParser.js

@@ -9,55 +9,85 @@ 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]);
+import { createObjectParser } from './objectParser.js';
+// 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]);
 // Word characters (unquoted, no special chars)
 // Note: {} are excluded so brace groups are parsed correctly
-const bashUnquotedWordCharsParser = promiseCompose(createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#]+/), match => match[0]);
+// # is excluded from the first character (starts a comment) but allowed mid-word
+const bashUnquotedWordCharsParser = promiseCompose(createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#][^\s\n|&;<>(){}$`"'\\]*/), match => match[0]);
 // Single quoted string: '...'
-const bashSingleQuotedParser = promiseCompose(createTupleParser([
-    createExactSequenceParser("'"),
-    promiseCompose(createRegExpParser(/[^']*/), match => match[0]),
-    createExactSequenceParser("'"),
-]), ([, value]) => ({
+const bashSingleQuotedParser = createObjectParser({
     type: 'singleQuoted',
-    value,
-}));
+    _open: createExactSequenceParser("'"),
+    value: promiseCompose(createRegExpParser(/[^']*/), match => match[0]),
+    _close: createExactSequenceParser("'"),
+});
 // Variable name
 const bashVariableNameParser = promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*|[0-9]+|[@*#?$!-]/), match => match[0]);
 // 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('`'),
+});
+// 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)),
+    _close: createExactSequenceParser('}'),
+});
+// Arithmetic expansion: $((expression))
+const bashArithmeticExpansionParser = createObjectParser({
+    type: 'arithmeticExpansion',
+    _open: createExactSequenceParser('$(('),
+    expression: promiseCompose(createRegExpParser(/(?:[^)]|\)(?!\)))*/), match => match[0]),
+    _close: createExactSequenceParser('))'),
+});
+// ANSI-C quoting: $'...'
+const bashAnsiCQuotedParser = createObjectParser({
+    type: 'singleQuoted',
+    _prefix: createExactSequenceParser('$'),
+    _open: createExactSequenceParser("'"),
+    value: promiseCompose(createRegExpParser(/(?:[^'\\]|\\.)*/), match => match[0]),
+    _close: createExactSequenceParser("'"),
+});
+// Process substitution: <(cmd) or >(cmd)
+const bashProcessSubstitutionParser = createObjectParser({
+    type: 'processSubstitution',
+    direction: promiseCompose(createRegExpParser(/[<>](?=\()/), match => match[0]),
+    _open: createExactSequenceParser('('),
+    _ws1: bashOptionalInlineWhitespaceParser,
+    command: createParserAccessorParser(() => bashCommandParser),
+    _ws2: bashOptionalInlineWhitespaceParser,
+    _close: createExactSequenceParser(')'),
+});
 // Double quoted string parts (inside "...")
 const bashDoubleQuotedPartParser = createDisjunctionParser([
+    bashBracedVariableParser,
+    bashArithmeticExpansionParser,
     bashSimpleVariableParser,
     bashCommandSubstitutionParser,
     bashBacktickSubstitutionParser,
@@ -71,21 +101,29 @@ const bashDoubleQuotedPartParser = createDisjunctionParser([
         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: '\\',
+    })),
 ]);
 // 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,
-}));
+    value: bashUnquotedWordCharsParser,
+});
 // Escape sequence outside quotes
 const bashEscapeParser = promiseCompose(createRegExpParser(/\\./), match => ({
     type: 'literal',
@@ -93,25 +131,33 @@ const bashEscapeParser = promiseCompose(createRegExpParser(/\\./), match => ({
 }));
 // Word part (any part of a word)
 const bashWordPartParser = createDisjunctionParser([
+    bashAnsiCQuotedParser,
     bashSingleQuotedParser,
     bashDoubleQuotedParser,
+    bashBracedVariableParser,
+    bashArithmeticExpansionParser,
     bashCommandSubstitutionParser,
     bashBacktickSubstitutionParser,
     bashSimpleVariableParser,
+    bashProcessSubstitutionParser,
     bashEscapeParser,
     bashLiteralWordPartParser,
+    // Bare $ not followed by a valid expansion start
+    promiseCompose(createRegExpParser(/\$/), () => ({
+        type: 'literal',
+        value: '$',
+    })),
 ]);
 // Word (sequence of word parts)
-export const bashWordParser = promiseCompose(createNonEmptyArrayParser(bashWordPartParser), parts => ({ parts }));
+export const bashWordParser = createObjectParser({
+    parts: createNonEmptyArrayParser(bashWordPartParser),
+});
 setParserName(bashWordParser, 'bashWordParser');
 // 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: promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/), match => match[0].slice(0, -1)),
+    value: createOptionalParser(bashWordParser),
+});
 // Redirect operators
 const bashRedirectOperatorParser = createDisjunctionParser([
     promiseCompose(createExactSequenceParser('>>'), () => '>>'),
@@ -124,16 +170,12 @@ const bashRedirectOperatorParser = createDisjunctionParser([
     promiseCompose(createExactSequenceParser('<'), () => '<'),
 ]);
 // 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(promiseCompose(createRegExpParser(/[0-9]+/), match => Number.parseInt(match[0], 10))),
+    operator: bashRedirectOperatorParser,
+    _ws: bashOptionalInlineWhitespaceParser,
+    target: bashWordParser,
+});
 // Word with optional trailing whitespace - for use in arrays
 const bashWordWithWhitespaceParser = promiseCompose(createTupleParser([
     bashWordParser,
@@ -146,8 +188,8 @@ const bashRedirectWithWhitespaceParser = promiseCompose(createTupleParser([
 ]), ([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 })),
+    createObjectParser({ type: 'redirect', redirect: bashRedirectWithWhitespaceParser }),
+    createObjectParser({ type: 'word', word: bashWordWithWhitespaceParser }),
 ]);
 // Simple command: [assignments] [name] [args] [redirects]
 export const bashSimpleCommandParser = promiseCompose(createTupleParser([
@@ -180,30 +222,26 @@ export const bashSimpleCommandParser = promiseCompose(createTupleParser([
 });
 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([
@@ -242,12 +280,12 @@ const bashListSeparatorParser = createDisjunctionParser([
 // 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 +323,13 @@ setParserName(bashCommandListParser, 'bashCommandListParser');
 // Top-level command parser
 export const bashCommandParser = bashCommandListParser;
 setParserName(bashCommandParser, 'bashCommandParser');
-// Script parser (handles leading/trailing whitespace)
+// Comment: # through end of line
+const bashOptionalCommentParser = createOptionalParser(promiseCompose(createRegExpParser(/#[^\n]*/), match => match[0]));
+// Script parser (handles leading/trailing whitespace and comments)
 export const bashScriptParser = promiseCompose(createTupleParser([
     bashOptionalInlineWhitespaceParser,
     bashCommandParser,
     bashOptionalInlineWhitespaceParser,
+    bashOptionalCommentParser,
 ]), ([, command]) => command);
 setParserName(bashScriptParser, 'bashScriptParser');

package/build/bashParser.test.js

@@ -98,6 +98,55 @@ test('double quoted string with variable', async (t) => {
         });
     }
 });
+test('double quoted string with trailing dollar', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "hello$"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: 'hello' },
+                        { type: 'literal', value: '$' },
+                    ],
+                }],
+        });
+    }
+});
+test('double quoted string with only dollar', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "$"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: '$' },
+                    ],
+                }],
+        });
+    }
+});
+test('grep with dollar anchor in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'grep "\\.ts$"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: '\\' },
+                        { type: 'literal', value: '.ts' },
+                        { type: 'literal', value: '$' },
+                    ],
+                }],
+        });
+    }
+});
+test('pipeline with dollar anchor in double quoted grep pattern', async (t) => {
+    const result = await runParser(bashScriptParser, 'ls -la /home | grep "\\.ts$" | grep -v "\\.test\\.ts"', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 3);
+});
 test('simple variable', async (t) => {
     const result = await runParser(bashScriptParser, 'echo $HOME', stringParserInputCompanion);
     const cmd = result.entries[0].pipeline.commands[0];
@@ -172,6 +221,119 @@ test('[[ treated as command name', async (t) => {
         t.is(cmd.args.length, 3); // -f, file, ]]
     }
 });
+// Braced variable expansion: ${VAR}
+test('braced variable expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${HOME}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Braced variable with default: ${VAR:-default}
+test('braced variable with default value', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${VAR:-default}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Arithmetic expansion: $((1+2))
+test('arithmetic expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $((1+2))', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'arithmeticExpansion');
+    }
+});
+// Bare $ at end of unquoted word
+test('bare dollar at end of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo$', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: 'foo' },
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Bare $ as its own unquoted word
+test('bare dollar as standalone unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Comment after command
+test('comment after command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello # this is a comment', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'hello' }],
+        });
+    }
+});
+// ANSI-C quoting: $'...'
+test('ansi-c quoting', async (t) => {
+    const result = await runParser(bashScriptParser, "echo $'hello\\nworld'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+    }
+});
+// Braced variable in double quotes: "${VAR}"
+test('braced variable in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "${HOME}"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'variableBraced');
+        }
+    }
+});
+// Arithmetic expansion in double quotes
+test('arithmetic expansion in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "$((1+2))"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'arithmeticExpansion');
+        }
+    }
+});
+// Process substitution: <(cmd)
+test('process substitution input', async (t) => {
+    const result = await runParser(bashScriptParser, 'diff <(sort file1) <(sort file2)', stringParserInputCompanion);
+    t.truthy(result);
+});
+// Line continuation (backslash-newline)
+test('line continuation', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello \\\nworld', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+// Hash in middle of unquoted word is literal, not a comment
+test('hash in middle of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo#bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'foo#bar' }],
+        });
+    }
+});
 test('if treated as command name', async (t) => {
     const result = await runParser(bashScriptParser, 'if true', stringParserInputCompanion);
     const cmd = result.entries[0].pipeline.commands[0];

package/build/bashParserEdgeCases.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/bashParserEdgeCases.test.js

@@ -0,0 +1,117 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { bashScriptParser } from './bashParser.js';
+// Braced variable expansion: ${VAR}
+test('braced variable expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${HOME}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Braced variable with default: ${VAR:-default}
+test('braced variable with default value', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${VAR:-default}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Arithmetic expansion: $((1+2))
+test('arithmetic expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $((1+2))', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'arithmeticExpansion');
+    }
+});
+// Bare $ at end of unquoted word
+test('bare dollar at end of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo$', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: 'foo' },
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Bare $ as its own unquoted word
+test('bare dollar as standalone unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Comment after command
+test('comment after command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello # this is a comment', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'hello' }],
+        });
+    }
+});
+// ANSI-C quoting: $'...'
+test('ansi-c quoting', async (t) => {
+    const result = await runParser(bashScriptParser, "echo $'hello\\nworld'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+    }
+});
+// Braced variable in double quotes: "${VAR}"
+test('braced variable in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "${HOME}"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'variableBraced');
+        }
+    }
+});
+// Arithmetic expansion in double quotes
+test('arithmetic expansion in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "$((1+2))"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'arithmeticExpansion');
+        }
+    }
+});
+// Process substitution: <(cmd)
+test('process substitution input', async (t) => {
+    const result = await runParser(bashScriptParser, 'diff <(sort file1) <(sort file2)', stringParserInputCompanion);
+    t.truthy(result);
+});
+// Line continuation (backslash-newline)
+test('line continuation', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello \\\nworld', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+// Hash in middle of unquoted word is literal, not a comment
+test('hash in middle of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo#bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'foo#bar' }],
+        });
+    }
+});