@futpib/parser 1.0.3 → 1.0.6

package/build/bashParser.js

@@ -0,0 +1,335 @@
+import { setParserName } from './parser.js';
+import { createExactSequenceParser } from './exactSequenceParser.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';
+// 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
+// # 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 = createObjectParser({
+    type: 'singleQuoted',
+    _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 = createObjectParser({
+    type: 'variable',
+    _dollar: createExactSequenceParser('$'),
+    name: bashVariableNameParser,
+});
+// Command substitution: $(...)
+const bashCommandSubstitutionParser = createObjectParser({
+    type: 'commandSubstitution',
+    _open: createExactSequenceParser('$('),
+    _ws1: bashOptionalInlineWhitespaceParser,
+    command: createParserAccessorParser(() => bashCommandParser),
+    _ws2: bashOptionalInlineWhitespaceParser,
+    _close: createExactSequenceParser(')'),
+});
+// Backtick substitution: `...`
+const bashBacktickSubstitutionParser = createObjectParser({
+    type: 'backtickSubstitution',
+    _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,
+    // 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: '\\',
+    })),
+]);
+// Double quoted string: "..."
+const bashDoubleQuotedParser = createObjectParser({
+    type: 'doubleQuoted',
+    _open: createExactSequenceParser('"'),
+    parts: createArrayParser(bashDoubleQuotedPartParser),
+    _close: createExactSequenceParser('"'),
+});
+// Literal word part (unquoted)
+const bashLiteralWordPartParser = createObjectParser({
+    type: 'literal',
+    value: bashUnquotedWordCharsParser,
+});
+// Escape sequence outside quotes
+const bashEscapeParser = promiseCompose(createRegExpParser(/\\./), match => ({
+    type: 'literal',
+    value: match[0].slice(1),
+}));
+// 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 = createObjectParser({
+    parts: createNonEmptyArrayParser(bashWordPartParser),
+});
+setParserName(bashWordParser, 'bashWordParser');
+// Assignment: NAME=value or NAME=
+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('>>'), () => '>>'),
+    promiseCompose(createExactSequenceParser('>&'), () => '>&'),
+    promiseCompose(createExactSequenceParser('>|'), () => '>|'),
+    promiseCompose(createExactSequenceParser('>'), () => '>'),
+    promiseCompose(createExactSequenceParser('<<<'), () => '<<<'),
+    promiseCompose(createExactSequenceParser('<<'), () => '<<'),
+    promiseCompose(createExactSequenceParser('<&'), () => '<&'),
+    promiseCompose(createExactSequenceParser('<'), () => '<'),
+]);
+// Redirect: [n]op word
+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,
+    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([
+    createObjectParser({ type: 'redirect', redirect: bashRedirectWithWhitespaceParser }),
+    createObjectParser({ type: 'word', word: bashWordWithWhitespaceParser }),
+]);
+// Simple command: [assignments] [name] [args] [redirects]
+export const bashSimpleCommandParser = 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 = [];
+    const redirects = [];
+    for (const item of items) {
+        if (item.type === 'word') {
+            words.push(item.word);
+        }
+        else {
+            redirects.push(item.redirect);
+        }
+    }
+    const [name, ...args] = words;
+    return {
+        type: 'simple',
+        name,
+        args,
+        redirects,
+        assignments,
+    };
+});
+setParserName(bashSimpleCommandParser, 'bashSimpleCommandParser');
+// Subshell: ( command )
+const bashSubshellParser = createObjectParser({
+    type: 'subshell',
+    _open: createExactSequenceParser('('),
+    _ws1: bashOptionalInlineWhitespaceParser,
+    body: createParserAccessorParser(() => bashCommandParser),
+    _ws2: bashOptionalInlineWhitespaceParser,
+    _close: createExactSequenceParser(')'),
+});
+setParserName(bashSubshellParser, 'bashSubshellParser');
+// Brace group: { command; }
+const bashBraceGroupParser = createObjectParser({
+    type: 'braceGroup',
+    _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([
+    bashSubshellParser,
+    bashBraceGroupParser,
+    bashSimpleCommandParser,
+]);
+setParserName(bashCommandUnitParser, 'bashCommandUnitParser');
+// Single pipe (not ||) - matches | only when not followed by another |
+const bashSinglePipeParser = promiseCompose(createRegExpParser(/\|(?!\|)/), match => match[0]);
+// Pipeline: [!] cmd [| cmd]...
+const bashPipelineParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('!'),
+        bashInlineWhitespaceParser,
+    ]), () => true)),
+    createSeparatedNonEmptyArrayParser(bashCommandUnitParser, createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashSinglePipeParser,
+        bashOptionalInlineWhitespaceParser,
+    ])),
+]), ([negated, commands]) => ({
+    type: 'pipeline',
+    negated: negated ?? false,
+    commands,
+}));
+setParserName(bashPipelineParser, 'bashPipelineParser');
+// Command list separator
+const bashListSeparatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('&&'), () => '&&'),
+    promiseCompose(createExactSequenceParser('||'), () => '||'),
+    promiseCompose(createExactSequenceParser(';'), () => ';'),
+    promiseCompose(createExactSequenceParser('&'), () => '&'),
+    promiseCompose(bashNewlineParser, () => '\n'),
+]);
+// Command list: pipeline [sep pipeline]...
+const bashCommandListParser = promiseCompose(createTupleParser([
+    bashPipelineParser,
+    createArrayParser(createObjectParser({
+        _ws1: bashOptionalInlineWhitespaceParser,
+        separator: bashListSeparatorParser,
+        _ws2: bashOptionalInlineWhitespaceParser,
+        pipeline: bashPipelineParser,
+    })),
+    createOptionalParser(promiseCompose(createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashListSeparatorParser,
+    ]), ([, separator]) => separator)),
+]), ([firstPipeline, rest, trailingSeparator]) => {
+    const entries = [];
+    if (rest.length === 0) {
+        entries.push({
+            pipeline: firstPipeline,
+            separator: trailingSeparator ?? undefined,
+        });
+    }
+    else {
+        entries.push({
+            pipeline: firstPipeline,
+            separator: rest[0].separator,
+        });
+        for (let i = 0; i < rest.length - 1; i++) {
+            entries.push({
+                pipeline: rest[i].pipeline,
+                separator: rest[i + 1].separator,
+            });
+        }
+        entries.push({
+            pipeline: rest[rest.length - 1].pipeline,
+            separator: trailingSeparator ?? undefined,
+        });
+    }
+    return {
+        type: 'list',
+        entries,
+    };
+});
+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]));
+// 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.d.ts

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

package/build/bashParser.test.js

@@ -0,0 +1,343 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { bashScriptParser, bashWordParser, bashSimpleCommandParser } from './bashParser.js';
+test('simple command parser - single word', async (t) => {
+    const result = await runParser(bashSimpleCommandParser, 'cmd', stringParserInputCompanion, { errorStack: true });
+    t.is(result.type, 'simple');
+    t.deepEqual(result.name, { parts: [{ type: 'literal', value: 'cmd' }] });
+});
+test('simple command parser - two words', async (t) => {
+    const result = await runParser(bashSimpleCommandParser, 'echo hello', stringParserInputCompanion);
+    t.is(result.type, 'simple');
+    t.deepEqual(result.name, { parts: [{ type: 'literal', value: 'echo' }] });
+    t.is(result.args.length, 1);
+});
+test('word parser - simple literal', async (t) => {
+    const result = await runParser(bashWordParser, 'hello', stringParserInputCompanion);
+    t.deepEqual(result, {
+        parts: [{ type: 'literal', value: 'hello' }],
+    });
+});
+test('word parser - variable', async (t) => {
+    const result = await runParser(bashWordParser, '$HOME', stringParserInputCompanion);
+    t.deepEqual(result, {
+        parts: [{ type: 'variable', name: 'HOME' }],
+    });
+});
+test('simple command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        entries: [{
+                pipeline: {
+                    type: 'pipeline',
+                    negated: false,
+                    commands: [{
+                            type: 'simple',
+                            name: { parts: [{ type: 'literal', value: 'echo' }] },
+                            args: [{ parts: [{ type: 'literal', value: 'hello' }] }],
+                            redirects: [],
+                            assignments: [],
+                        }],
+                },
+                separator: undefined,
+            }],
+    });
+});
+test('simple command with multiple args', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello world', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'simple');
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+test('pipeline', async (t) => {
+    const result = await runParser(bashScriptParser, 'cat file | grep pattern', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 2);
+});
+test('redirect output', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo > file', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.redirects.length, 1);
+        t.is(cmd.redirects[0].operator, '>');
+    }
+});
+test('redirect with fd', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd 2>&1', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.redirects.length, 1);
+        t.is(cmd.redirects[0].fd, 2);
+        t.is(cmd.redirects[0].operator, '>&');
+    }
+});
+test('single quoted string', async (t) => {
+    const result = await runParser(bashScriptParser, "echo 'hello world'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'singleQuoted', value: 'hello world' }],
+        });
+    }
+});
+test('double quoted string with variable', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "hello $name"', 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: 'variable', name: 'name' },
+                    ],
+                }],
+        });
+    }
+});
+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];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'variable', name: 'HOME' }],
+        });
+    }
+});
+test('command substitution', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $(pwd)', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'commandSubstitution');
+    }
+});
+test('backtick substitution', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo `pwd`', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'backtickSubstitution');
+    }
+});
+test('subshell', async (t) => {
+    const result = await runParser(bashScriptParser, '(cd dir; pwd)', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'subshell');
+});
+test('brace group', async (t) => {
+    const result = await runParser(bashScriptParser, '{ echo hello; }', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'braceGroup');
+});
+test('command list with &&', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1 && cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, '&&');
+});
+test('command list with ||', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1 || cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, '||');
+});
+test('command list with ;', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1; cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, ';');
+});
+test('background command', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd &', stringParserInputCompanion);
+    t.is(result.entries[0].separator, '&');
+});
+test('assignment', async (t) => {
+    const result = await runParser(bashScriptParser, 'VAR=value cmd', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.assignments.length, 1);
+        t.is(cmd.assignments[0].name, 'VAR');
+    }
+});
+test('negated pipeline', async (t) => {
+    const result = await runParser(bashScriptParser, '! cmd', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.negated, true);
+});
+test('complex pipeline with redirects', async (t) => {
+    const result = await runParser(bashScriptParser, 'cat file 2>/dev/null | grep pattern | sort > output', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 3);
+});
+test('[[ treated as command name', async (t) => {
+    const result = await runParser(bashScriptParser, '[[ -f file ]]', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: '[[' }] });
+        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];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: 'if' }] });
+    }
+});

package/build/bashParserEdgeCases.test.d.ts

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