/**

* Pure-TypeScript bash parser producing tree-sitter-bash-compatible ASTs.

*

* Downstream code in parser.ts, ast.ts, prefix.ts, ParsedCommand.ts walks this

* by field name. startIndex/endIndex are UTF-8 BYTE offsets (not JS string

* indices).

*

* Grammar reference: tree-sitter-bash. Validated against a 3449-input golden

* corpus generated from the WASM parser.

*/

export type TsNode = {

type: string

text: string

startIndex: number

endIndex: number

children: TsNode[]

}

type ParserModule = {

parse: (source: string, timeoutMs?: number) => TsNode | null

}

/**

* 50ms wall-clock cap — bails out on pathological/adversarial input.

* Pass `Infinity` via `parse(src, Infinity)` to disable (e.g. correctness

* tests, where CI jitter would otherwise cause spurious null returns).

*/

const PARSE_TIMEOUT_MS = 50

/** Node budget cap — bails out before OOM on deeply nested input. */

const MAX_NODES = 50_000

const MODULE: ParserModule = { parse: parseSource }

const READY = Promise.resolve()

/** No-op: pure-TS parser needs no async init. Kept for API compatibility. */

export function ensureParserInitialized(): Promise<void> {

return READY

}

/** Always succeeds — pure-TS needs no init. */

export function getParserModule(): ParserModule | null {

return MODULE

}

// ───────────────────────────── Tokenizer ─────────────────────────────

type TokenType =

| 'WORD'

| 'NUMBER'

| 'OP'

| 'NEWLINE'

| 'COMMENT'

| 'DQUOTE'

| 'SQUOTE'

| 'ANSI_C'

| 'DOLLAR'

| 'DOLLAR_PAREN'

| 'DOLLAR_BRACE'

| 'DOLLAR_DPAREN'

| 'BACKTICK'

| 'LT_PAREN'

| 'GT_PAREN'

| 'EOF'

type Token = {

type: TokenType

value: string

/** UTF-8 byte offset of first char */

start: number

/** UTF-8 byte offset one past last char */

end: number

}

const SPECIAL_VARS = new Set(['?', '$', '@', '*', '#', '-', '!', '_'])

const DECL_KEYWORDS = new Set([

'export',

'declare',

'typeset',

'readonly',

'local',

])

export const SHELL_KEYWORDS = new Set([

'if',

'then',

'elif',

'else',

'fi',

'while',

'until',

'for',

'in',

'do',

'done',

'case',

'esac',

'function',

'select',

])

/**

* Lexer state. Tracks both JS-string index (for charAt) and UTF-8 byte offset

* (for TsNode positions). ASCII fast path: byte == char index. Non-ASCII

* advances byte count per-codepoint.

*/

type Lexer = {

src: string

len: number

/** JS string index */

i: number

/** UTF-8 byte offset */

b: number

/** Pending heredoc delimiters awaiting body scan at next newline */

heredocs: HeredocPending[]

/** Precomputed byte offset for each char index (lazy for non-ASCII) */

byteTable: Uint32Array | null

}

type HeredocPending = {

delim: string

stripTabs: boolean

quoted: boolean

/** Filled after body scan */

bodyStart: number

bodyEnd: number

endStart: number

endEnd: number

}

function makeLexer(src: string): Lexer {

return {

src,

len: src.length,

i: 0,

b: 0,

heredocs: [],

byteTable: null,

}

}

/** Advance one JS char, updating byte offset for UTF-8. */

function advance(L: Lexer): void {

const c = L.src.charCodeAt(L.i)

L.i++

if (c < 0x80) {

L.b++

} else if (c < 0x800) {

L.b += 2

} else if (c >= 0xd800 && c <= 0xdbff) {

// High surrogate — next char completes the pair, total 4 UTF-8 bytes

L.b += 4

L.i++

} else {

L.b += 3

}

}

function peek(L: Lexer, off = 0): string {

return L.i + off < L.len ? L.src[L.i + off]! : ''

}

function byteAt(L: Lexer, charIdx: number): number {

// Fast path: ASCII-only prefix means char idx == byte idx

if (L.byteTable) return L.byteTable[charIdx]!

// Build table on first non-trivial lookup

const t = new Uint32Array(L.len + 1)

let b = 0

let i = 0

while (i < L.len) {

t[i] = b

const c = L.src.charCodeAt(i)

if (c < 0x80) {

b++

i++

} else if (c < 0x800) {

b += 2

i++

} else if (c >= 0xd800 && c <= 0xdbff) {

t[i + 1] = b + 2

b += 4

i += 2

} else {

b += 3

i++

}

}

t[L.len] = b

L.byteTable = t

return t[charIdx]!

}

function isWordChar(c: string): boolean {

// Bash word chars: alphanumeric + various punctuation that doesn't start operators

return (

(c >= 'a' && c <= 'z') ||

(c >= 'A' && c <= 'Z') ||

(c >= '0' && c <= '9') ||

c === '_' ||

c === '/' ||

c === '.' ||

c === '-' ||

c === '+' ||

c === ':' ||

c === '@' ||

c === '%' ||

c === ',' ||

c === '~' ||

c === '^' ||

c === '?' ||

c === '*' ||

c === '!' ||

c === '=' ||

c === '[' ||

c === ']'

)

}

function isWordStart(c: string): boolean {

return isWordChar(c) || c === '\\'

}

function isIdentStart(c: string): boolean {

return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_'

}

function isIdentChar(c: string): boolean {

return isIdentStart(c) || (c >= '0' && c <= '9')

}

function isDigit(c: string): boolean {

return c >= '0' && c <= '9'

}

function isHexDigit(c: string): boolean {

return isDigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')

}

function isBaseDigit(c: string): boolean {

// Bash BASE#DIGITS: digits, letters, @ and _ (up to base 64)

return isIdentChar(c) || c === '@'

}

/**

* Unquoted heredoc delimiter chars. Bash accepts most non-metacharacters —

* not just identifiers. Stop at whitespace, redirects, pipe/list operators,

* and structural tokens. Allows !, -, ., +, etc. (e.g. <<!HEREDOC!).

*/

function isHeredocDelimChar(c: string): boolean {

return (

c !== '' &&

c !== ' ' &&

c !== '\t' &&

c !== '\n' &&

c !== '<' &&

c !== '>' &&

c !== '|' &&

c !== '&' &&

c !== ';' &&

c !== '(' &&

c !== ')' &&

c !== "'" &&

c !== '"' &&

c !== '`' &&

c !== '\\'

)

}

function skipBlanks(L: Lexer): void {

while (L.i < L.len) {

const c = L.src[L.i]!

if (c === ' ' || c === '\t' || c === '\r') {

// \r is whitespace per tree-sitter-bash extras /\s/ — handles CRLF inputs

advance(L)

} else if (c === '\\') {

const nx = L.src[L.i + 1]

if (nx === '\n' || (nx === '\r' && L.src[L.i + 2] === '\n')) {

// Line continuation — tree-sitter extras: /\\\r?\n/

advance(L)

advance(L)

if (nx === '\r') advance(L)

} else if (nx === ' ' || nx === '\t') {

// \<space> or \<tab> — tree-sitter's _whitespace is /\\?[ \t\v]+/

advance(L)

advance(L)

} else {

break

}

} else {

break

}

}

}

/**

* Scan next token. Context-sensitive: `cmd` mode treats [ as operator (test

* command start), `arg` mode treats [ as word char (glob/subscript).

*/

function nextToken(L: Lexer, ctx: 'cmd' | 'arg' = 'arg'): Token {

skipBlanks(L)

const start = L.b

if (L.i >= L.len) return { type: 'EOF', value: '', start, end: start }

const c = L.src[L.i]!

const c1 = peek(L, 1)

const c2 = peek(L, 2)

if (c === '\n') {

advance(L)

return { type: 'NEWLINE', value: '\n', start, end: L.b }

}

if (c === '#') {

const si = L.i

while (L.i < L.len && L.src[L.i] !== '\n') advance(L)

return {

type: 'COMMENT',

value: L.src.slice(si, L.i),

start,

end: L.b,

}

}

// Multi-char operators (longest match first)

if (c === '&' && c1 === '&') {

advance(L)

advance(L)

return { type: 'OP', value: '&&', start, end: L.b }

}

if (c === '|' && c1 === '|') {

advance(L)

advance(L)

return { type: 'OP', value: '||', start, end: L.b }

}

if (c === '|' && c1 === '&') {

advance(L)

advance(L)

return { type: 'OP', value: '|&', start, end: L.b }

}

if (c === ';' && c1 === ';' && c2 === '&') {

advance(L)

advance(L)

advance(L)

return { type: 'OP', value: ';;&', start, end: L.b }

}

if (c === ';' && c1 === ';') {

advance(L)

advance(L)

return { type: 'OP', value: ';;', start, end: L.b }

}

if (c === ';' && c1 === '&') {

advance(L)

advance(L)

return { type: 'OP', value: ';&', start, end: L.b }

}

if (c === '>' && c1 === '>') {

advance(L)

advance(L)

return { type: 'OP', value: '>>', start, end: L.b }

}

if (c === '>' && c1 === '&' && c2 === '-') {

advance(L)

advance(L)

advance(L)

return { type: 'OP', value: '>&-', start, end: L.b }

}

if (c === '>' && c1 === '&') {

advance(L)

advance(L)

return { type: 'OP', value: '>&', start, end: L.b }

}

if (c === '>' && c1 === '|') {

advance(L)

advance(L)

return { type: 'OP', value: '>|', start, end: L.b }

}

if (c === '&' && c1 === '>' && c2 === '>') {

advance(L)

advance(L)

advance(L)

return { type: 'OP', value: '&>>', start, end: L.b }

}

if (c === '&' && c1 === '>') {

advance(L)

advance(L)

return { type: 'OP', value: '&>', start, end: L.b }

}

if (c === '<' && c1 === '<' && c2 === '<') {

advance(L)

advance(L)

advance(L)

return { type: 'OP', value: '<<<', start, end: L.b }

}

if (c === '<' && c1 === '<' && c2 === '-') {

advance(L)

advance(L)

advance(L)

return { type: 'OP', value: '<<-', start, end: L.b }

}

if (c === '<' && c1 === '<') {

advance(L)

advance(L)

return { type: 'OP', value: '<<', start, end: L.b }

}

if (c === '<' && c1 === '&' && c2 === '-') {

advance(L)

advance(L)

advance(L)

return { type: 'OP', value: '<&-', start, end: L.b }

}

if (c === '<' && c1 === '&') {

advance(L)

advance(L)

return { type: 'OP', value: '<&', start, end: L.b }

}

if (c === '<' && c1 === '(') {

advance(L)

advance(L)

return { type: 'LT_PAREN', value: '<(', start, end: L.b }

}

if (c === '>' && c1 === '(') {

advance(L)

advance(L)

return { type: 'GT_PAREN', value: '>(', start, end: L.b }

}

if (c === '(' && c1 === '(') {

advance(L)

advance(L)

return { type: 'OP', value: '((', start, end: L.b }

}

if (c === ')' && c1 === ')') {

advance(L)

advance(L)

return { type: 'OP', value: '))', start, end: L.b }

}

if (c === '|' || c === '&' || c === ';' || c === '>' || c === '<') {

advance(L)

return { type: 'OP', value: c, start, end: L.b }

}

if (c === '(' || c === ')') {

advance(L)

return { type: 'OP', value: c, start, end: L.b }

}

// In cmd position, [ [[ { start test/group; in arg position they're word chars

if (ctx === 'cmd') {

if (c === '[' && c1 === '[') {

advance(L)

advance(L)

return { type: 'OP', value: '[[', start, end: L.b }

}

if (c === '[') {

advance(L)

return { type: 'OP', value: '[', start, end: L.b }

}

if (c === '{' && (c1 === ' ' || c1 === '\t' || c1 === '\n')) {

advance(L)

return { type: 'OP', value: '{', start, end: L.b }

}

if (c === '}') {

advance(L)

return { type: 'OP', value: '}', start, end: L.b }

}

if (c === '!' && (c1 === ' ' || c1 === '\t')) {

advance(L)

return { type: 'OP', value: '!', start, end: L.b }

}

}

if (c === '"') {

advance(L)

return { type: 'DQUOTE', value: '"', start, end: L.b }

}

if (c === "'") {

const si = L.i

advance(L)

while (L.i < L.len && L.src[L.i] !== "'") advance(L)

if (L.i < L.len) advance(L)

return {

type: 'SQUOTE',

value: L.src.slice(si, L.i),

start,

end: L.b,

}

}

if (c === '$') {

if (c1 === '(' && c2 === '(') {

advance(L)

advance(L)

advance(L)

return { type: 'DOLLAR_DPAREN', value: '$((', start, end: L.b }

}

if (c1 === '(') {

advance(L)

advance(L)

return { type: 'DOLLAR_PAREN', value: '$(', start, end: L.b }

}

if (c1 === '{') {

advance(L)

advance(L)

return { type: 'DOLLAR_BRACE', value: '${', start, end: L.b }

}

if (c1 === "'") {

// ANSI-C string $'...'

const si = L.i

advance(L)

advance(L)

while (L.i < L.len && L.src[L.i] !== "'") {

if (L.src[L.i] === '\\' && L.i + 1 < L.len) advance(L)

advance(L)

}

if (L.i < L.len) advance(L)

return {

type: 'ANSI_C',

value: L.src.slice(si, L.i),

start,

end: L.b,

}

}

advance(L)

return { type: 'DOLLAR', value: '$', start, end: L.b }

}

if (c === '`') {

advance(L)

return { type: 'BACKTICK', value: '`', start, end: L.b }

}

// File descriptor before redirect: digit+ immediately followed by > or <

if (isDigit(c)) {

let j = L.i

while (j < L.len && isDigit(L.src[j]!)) j++

const after = j < L.len ? L.src[j]! : ''

if (after === '>' || after === '<') {

const si = L.i

while (L.i < j) advance(L)

return {

type: 'WORD',

value: L.src.slice(si, L.i),

start,

end: L.b,

}

}

}

// Word / number

if (isWordStart(c) || c === '{' || c === '}') {

const si = L.i

while (L.i < L.len) {

const ch = L.src[L.i]!

if (ch === '\\') {

if (L.i + 1 >= L.len) {

// Trailing `\` at EOF — tree-sitter excludes it from the word and

// emits a sibling ERROR. Stop here so the word ends before `\`.

break

}

// Escape next char (including \n for line continuation mid-word)

if (L.src[L.i + 1] === '\n') {

advance(L)

advance(L)

continue

}

advance(L)

advance(L)

continue

}

if (!isWordChar(ch) && ch !== '{' && ch !== '}') {

break

}

advance(L)

}

if (L.i > si) {

const v = L.src.slice(si, L.i)

// Number: optional sign then digits only

if (/^-?\d+$/.test(v)) {

return { type: 'NUMBER', value: v, start, end: L.b }

}

return { type: 'WORD', value: v, start, end: L.b }

}

// Empty word (lone `\` at EOF) — fall through to single-char consumer

}

// Unknown char — consume as single-char word

advance(L)

return { type: 'WORD', value: c, start, end: L.b }

}

// ───────────────────────────── Parser ─────────────────────────────

type ParseState = {

L: Lexer

src: string

srcBytes: number

/** True when byte offsets == char indices (no multi-byte UTF-8) */

isAscii: boolean

nodeCount: number

deadline: number

aborted: boolean

/** Depth of backtick nesting — inside `...`, ` terminates words */

inBacktick: number

/** When set, parseSimpleCommand stops at this token (for `[` backtrack) */

stopToken: string | null

}

function parseSource(source: string, timeoutMs?: number): TsNode | null {

const L = makeLexer(source)

const srcBytes = byteLengthUtf8(source)

const P: ParseState = {

L,

src: source,

srcBytes,

isAscii: srcBytes === source.length,

nodeCount: 0,

deadline: performance.now() + (timeoutMs ?? PARSE_TIMEOUT_MS),

aborted: false,

inBacktick: 0,

stopToken: null,

}

try {

const program = parseProgram(P)

if (P.aborted) return null

return program

} catch {

return null

}

}

function byteLengthUtf8(s: string): number {

let b = 0

for (let i = 0; i < s.length; i++) {

const c = s.charCodeAt(i)

if (c < 0x80) b++

else if (c < 0x800) b += 2

else if (c >= 0xd800 && c <= 0xdbff) {

b += 4

i++

} else b += 3

}

return b

}

function checkBudget(P: ParseState): void {

P.nodeCount++

if (P.nodeCount > MAX_NODES) {

P.aborted = true

throw new Error('budget')

}

if ((P.nodeCount & 0x7f) === 0 && performance.now() > P.deadline) {

P.aborted = true

throw new Error('timeout')

}

}

/** Build a node. Slices text from source by byte range via char-index lookup. */

function mk(

P: ParseState,

type: string,

start: number,

end: number,

children: TsNode[],

): TsNode {

checkBudget(P)

return {

type,

text: sliceBytes(P, start, end),

startIndex: start,

endIndex: end,

children,

}

}

function sliceBytes(P: ParseState, startByte: number, endByte: number): string {

if (P.isAscii) return P.src.slice(startByte, endByte)

// Find char indices for byte offsets. Build byte table if needed.

const L = P.L

if (!L.byteTable) byteAt(L, 0)

const t = L.byteTable!

// Binary search for char index where byte offset matches

let lo = 0

let hi = P.src.length

while (lo < hi) {

const m = (lo + hi) >>> 1

if (t[m]! < startByte) lo = m + 1

else hi = m

}

const sc = lo

lo = sc

hi = P.src.length

while (lo < hi) {

const m = (lo + hi) >>> 1

if (t[m]! < endByte) lo = m + 1

else hi = m

}

return P.src.slice(sc, lo)

}

function leaf(P: ParseState, type: string, tok: Token): TsNode {

return mk(P, type, tok.start, tok.end, [])

}

function parseProgram(P: ParseState): TsNode {

const children: TsNode[] = []

// Skip leading whitespace & newlines — program start is first content byte

skipBlanks(P.L)

while (true) {

const save = saveLex(P.L)

const t = nextToken(P.L, 'cmd')

if (t.type === 'NEWLINE') {

skipBlanks(P.L)

continue

}

restoreLex(P.L, save)

break

}

const progStart = P.L.b

while (P.L.i < P.L.len) {

const save = saveLex(P.L)

const t = nextToken(P.L, 'cmd')

if (t.type === 'EOF') break

if (t.type === 'NEWLINE') continue

if (t.type === 'COMMENT') {

children.push(leaf(P, 'comment', t))

continue

}

restoreLex(P.L, save)

const stmts = parseStatements(P, null)

for (const s of stmts) children.push(s)

if (stmts.length === 0) {

// Couldn't parse — emit ERROR and skip one token

const errTok = nextToken(P.L, 'cmd')

if (errTok.type === 'EOF') break

// Stray `;;` at program level (e.g., `var=;;` outside case) — tree-sitter

// silently elides. Keep leading `;` as ERROR (security: paste artifact).

if (

errTok.type === 'OP' &&

errTok.value === ';;' &&

children.length > 0

) {

continue

}

children.push(mk(P, 'ERROR', errTok.start, errTok.end, []))

}

}

// tree-sitter includes trailing whitespace in program extent

const progEnd = children.length > 0 ? P.srcBytes : progStart

return mk(P, 'program', progStart, progEnd, children)

}

/** Packed as (b << 16) | i — avoids heap alloc on every backtrack. */

type LexSave = number

function saveLex(L: Lexer): LexSave {

return L.b * 0x10000 + L.i

}

function restoreLex(L: Lexer, s: LexSave): void {

L.i = s & 0xffff

L.b = s >>> 16

}

/**

* Parse a sequence of statements separated by ; & newline. Returns a flat list

* where ; and & are sibling leaves (NOT wrapped in 'list' — only && || get

* that). Stops at terminator or EOF.

*/

function parseStatements(P: ParseState, terminator: string | null): TsNode[] {

const out: TsNode[] = []

while (true) {

skipBlanks(P.L)

const save = saveLex(P.L)

const t = nextToken(P.L, 'cmd')

if (t.type === 'EOF') {

restoreLex(P.L, save)

break

}

if (t.type === 'NEWLINE') {

// Process pending heredocs

if (P.L.heredocs.length > 0) {

scanHeredocBodies(P)

}

continue

}

if (t.type === 'COMMENT') {

out.push(leaf(P, 'comment', t))

continue

}

if (terminator && t.type === 'OP' && t.value === terminator) {

restoreLex(P.L, save)

break

}

if (

t.type === 'OP' &&

(t.value === ')' ||

t.value === '}' ||

t.value === ';;' ||

t.value === ';&' ||

t.value === ';;&' ||

t.value === '))' ||

t.value === ']]' ||

t.value === ']')

) {

restoreLex(P.L, save)

break

}

if (t.type === 'BACKTICK' && P.inBacktick > 0) {

restoreLex(P.L, save)

break

}

if (

t.type === 'WORD' &&

(t.value === 'then' ||

t.value === 'elif' ||

t.value === 'else' ||

t.value === 'fi' ||

t.value === 'do' ||

t.value === 'done' ||

t.value === 'esac')

) {

restoreLex(P.L, save)

break

}

restoreLex(P.L, save)

const stmt = parseAndOr(P)

if (!stmt) break

out.push(stmt)

// Look for separator

skipBlanks(P.L)

const save2 = saveLex(P.L)

const sep = nextToken(P.L, 'cmd')

if (sep.type === 'OP' && (sep.value === ';' || sep.value === '&')) {

// Check if terminator follows — if so, emit separator but stop

const save3 = saveLex(P.L)

const after = nextToken(P.L, 'cmd')

restoreLex(P.L, save3)

out.push(leaf(P, sep.value, sep))

if (

after.type === 'EOF' ||

(after.type === 'OP' &&

(after.value === ')' ||

after.value === '}' ||

after.value === ';;' ||

after.value === ';&' ||

after.value === ';;&')) ||

(after.type === 'WORD' &&

(after.value === 'then' ||

after.value === 'elif' ||

after.value === 'else' ||

after.value === 'fi' ||

after.value === 'do' ||

after.value === 'done' ||

after.value === 'esac'))

) {

// Trailing separator — don't include it at program level unless

// there's content after. But at inner levels we keep it.

continue

}

} else if (sep.type === 'NEWLINE') {

if (P.L.heredocs.length > 0) {

scanHeredocBodies(P)

}

continue

} else {

restoreLex(P.L, save2)

}

}

// Trim trailing separator if at program level

return out

}

/**

* Parse pipeline chains joined by && ||. Left-associative nesting.

* tree-sitter quirk: trailing redirect on the last pipeline wraps the ENTIRE

* list in a redirected_statement — `a > x && b > y` becomes

* redirected_statement(list(redirected_statement(a,>x), &&, b), >y).

*/

function parseAndOr(P: ParseState): TsNode | null {

let left = parsePipeline(P)

if (!left) return null

while (true) {

const save = saveLex(P.L)

const t = nextToken(P.L, 'cmd')

if (t.type === 'OP' && (t.value === '&&' || t.value === '||')) {

const op = leaf(P, t.value, t)

skipNewlines(P)

const right = parsePipeline(P)

if (!right) {

left = mk(P, 'list', left.startIndex, op.endIndex, [left, op])

break

}

// If right is a redirected_statement, hoist its redirects to wrap the list.

if (right.type === 'redirected_statement' && right.children.length >= 2) {

const inner = right.children[0]!

const redirs = right.children.slice(1)

const listNode = mk(P, 'list', left.startIndex, inner.endIndex, [

left,

op,

inner,

])

const lastR = redirs[redirs.length - 1]!

left = mk(

P,

'redirected_statement',

listNode.startIndex,

lastR.endIndex,

[listNode, ...redirs],

)

} else {

left = mk(P, 'list', left.startIndex, right.endIndex, [left, op, right])

}

} else {

restoreLex(P.L, save)

break

}

}

return left

}

function skipNewlines(P: ParseState): void {

while (true) {

const save = saveLex(P.L)

const t = nextToken(P.L, 'cmd')

if (t.type !== 'NEWLINE') {

restoreLex(P.L, save)

break

}

}

}

/**

* Parse commands joined by | or |&. Flat children with operator leaves.

* tree-sitter quirk: `a | b 2>nul | c` hoists the redirect on `b` to wrap

* the preceding pipeline fragment — pipeline(redirected_statement(

* pipeline(a,|,b), 2>nul), |, c).

*/

function parsePipeline(P: ParseState): TsNode | null {

let first = parseCommand(P)

if (!first) return null

const parts: TsNode[] = [first]

while (true) {

const save = saveLex(P.L)

const t = nextToken(P.L, 'cmd')

if (t.type === 'OP' && (t.value === '|' || t.value === '|&')) {

const op = leaf(P, t.value, t)

skipNewlines(P)

const next = parseCommand(P)

if (!next) {

parts.push(op)

break

}

// Hoist trailing redirect on `next` to wrap current pipeline fragment

if (

next.type === 'redirected_statement' &&

next.children.length >= 2 &&

parts.length >= 1

) {

const inner = next.children[0]!

const redirs = next.children.slice(1)

// Wrap existing parts + op + inner as a pipeline

const pipeKids = [...parts, op, inner]

const pipeNode = mk(

P,

'pipeline',

pipeKids[0]!.startIndex,

inner.endIndex,

pipeKids,

)

const lastR = redirs[redirs.length - 1]!

const wrapped = mk(

P,

'redirected_statement',

pipeNode.startIndex,

lastR.endIndex,

[pipeNode, ...redirs],

)

parts.length = 0

parts.push(wrapped)

first = wrapped

continue

}

parts.push(op, next)

} else {

restoreLex(P.L, save)

break

}

}

if (parts.length === 1) return parts[0]!

const last = parts[parts.length - 1]!

return mk(P, 'pipeline', parts[0]!.startIndex, last.endIndex, parts)

}

/** Parse a single command: simple, compound, or control structure. */

function parseCommand(P: ParseState): TsNode | null {

skipBlanks(P.L)

const save = saveLex(P.L)

const t = nextToken(P.L, 'cmd')

if (t.type === 'EOF') {