@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/bash/bashParser.js

@@ -1,4355 +0,0 @@
-/**
- * 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.
- */
-/**
- * 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 = { parse: parseSource };
-const READY = Promise.resolve();
-/** No-op: pure-TS parser needs no async init. Kept for API compatibility. */
-export function ensureParserInitialized() {
-    return READY;
-}
-/** Always succeeds — pure-TS needs no init. */
-export function getParserModule() {
-    return MODULE;
-}
-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',
-]);
-function makeLexer(src) {
-    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) {
-    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, off = 0) {
-    return L.i + off < L.len ? L.src[L.i + off] : '';
-}
-function byteAt(L, charIdx) {
-    // 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) {
-    // 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) {
-    return isWordChar(c) || c === '\\';
-}
-function isIdentStart(c) {
-    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_';
-}
-function isIdentChar(c) {
-    return isIdentStart(c) || (c >= '0' && c <= '9');
-}
-function isDigit(c) {
-    return c >= '0' && c <= '9';
-}
-function isHexDigit(c) {
-    return isDigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
-}
-function isBaseDigit(c) {
-    // 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) {
-    return (c !== '' &&
-        c !== ' ' &&
-        c !== '\t' &&
-        c !== '\n' &&
-        c !== '<' &&
-        c !== '>' &&
-        c !== '|' &&
-        c !== '&' &&
-        c !== ';' &&
-        c !== '(' &&
-        c !== ')' &&
-        c !== "'" &&
-        c !== '"' &&
-        c !== '`' &&
-        c !== '\\');
-}
-function skipBlanks(L) {
-    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, ctx = 'arg') {
-    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 };
-}
-function parseSource(source, timeoutMs) {
-    const L = makeLexer(source);
-    const srcBytes = byteLengthUtf8(source);
-    const P = {
-        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) {
-    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) {
-    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, type, start, end, children) {
-    checkBudget(P);
-    return {
-        type,
-        text: sliceBytes(P, start, end),
-        startIndex: start,
-        endIndex: end,
-        children,
-    };
-}
-function sliceBytes(P, startByte, endByte) {
-    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, type, tok) {
-    return mk(P, type, tok.start, tok.end, []);
-}
-function parseProgram(P) {
-    const children = [];
-    // 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);
-}
-function saveLex(L) {
-    return L.b * 0x10000 + L.i;
-}
-function restoreLex(L, s) {
-    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, terminator) {
-    const out = [];
-    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) {
-    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) {
-    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) {
-    let first = parseCommand(P);
-    if (!first)
-        return null;
-    const parts = [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) {
-    skipBlanks(P.L);
-    const save = saveLex(P.L);
-    const t = nextToken(P.L, 'cmd');
-    if (t.type === 'EOF') {
-        restoreLex(P.L, save);
-        return null;
-    }
-    // Negation — tree-sitter wraps just the command, redirects go outside.
-    // `! cmd > out` → redirected_statement(negated_command(!, cmd), >out)
-    if (t.type === 'OP' && t.value === '!') {
-        const bang = leaf(P, '!', t);
-        const inner = parseCommand(P);
-        if (!inner) {
-            restoreLex(P.L, save);
-            return null;
-        }
-        // If inner is a redirected_statement, hoist redirects outside negation
-        if (inner.type === 'redirected_statement' && inner.children.length >= 2) {
-            const cmd = inner.children[0];
-            const redirs = inner.children.slice(1);
-            const neg = mk(P, 'negated_command', bang.startIndex, cmd.endIndex, [
-                bang,
-                cmd,
-            ]);
-            const lastR = redirs[redirs.length - 1];
-            return mk(P, 'redirected_statement', neg.startIndex, lastR.endIndex, [
-                neg,
-                ...redirs,
-            ]);
-        }
-        return mk(P, 'negated_command', bang.startIndex, inner.endIndex, [
-            bang,
-            inner,
-        ]);
-    }
-    if (t.type === 'OP' && t.value === '(') {
-        const open = leaf(P, '(', t);
-        const body = parseStatements(P, ')');
-        const closeTok = nextToken(P.L, 'cmd');
-        const close = closeTok.type === 'OP' && closeTok.value === ')'
-            ? leaf(P, ')', closeTok)
-            : mk(P, ')', open.endIndex, open.endIndex, []);
-        const node = mk(P, 'subshell', open.startIndex, close.endIndex, [
-            open,
-            ...body,
-            close,
-        ]);
-        return maybeRedirect(P, node);
-    }
-    if (t.type === 'OP' && t.value === '((') {
-        const open = leaf(P, '((', t);
-        const exprs = parseArithCommaList(P, '))', 'var');
-        const closeTok = nextToken(P.L, 'cmd');
-        const close = closeTok.value === '))'
-            ? leaf(P, '))', closeTok)
-            : mk(P, '))', open.endIndex, open.endIndex, []);
-        return mk(P, 'compound_statement', open.startIndex, close.endIndex, [
-            open,
-            ...exprs,
-            close,
-        ]);
-    }
-    if (t.type === 'OP' && t.value === '{') {
-        const open = leaf(P, '{', t);
-        const body = parseStatements(P, '}');
-        const closeTok = nextToken(P.L, 'cmd');
-        const close = closeTok.type === 'OP' && closeTok.value === '}'
-            ? leaf(P, '}', closeTok)
-            : mk(P, '}', open.endIndex, open.endIndex, []);
-        const node = mk(P, 'compound_statement', open.startIndex, close.endIndex, [
-            open,
-            ...body,
-            close,
-        ]);
-        return maybeRedirect(P, node);
-    }
-    if (t.type === 'OP' && (t.value === '[' || t.value === '[[')) {
-        const open = leaf(P, t.value, t);
-        const closer = t.value === '[' ? ']' : ']]';
-        // Grammar: `[` can contain choice(_expression, redirected_statement).
-        // Try _expression first; if we don't reach `]`, backtrack and parse as
-        // redirected_statement (handles `[ ! cmd -v go &>/dev/null ]`).
-        const exprSave = saveLex(P.L);
-        let expr = parseTestExpr(P, closer);
-        skipBlanks(P.L);
-        if (t.value === '[' && peek(P.L) !== ']') {
-            // Expression parse didn't reach `]` — try as redirected_statement.
-            // Thread `]` stop-token so parseSimpleCommand doesn't eat it as arg.
-            restoreLex(P.L, exprSave);
-            const prevStop = P.stopToken;
-            P.stopToken = ']';
-            const rstmt = parseCommand(P);
-            P.stopToken = prevStop;
-            if (rstmt && rstmt.type === 'redirected_statement') {
-                expr = rstmt;
-            }
-            else {
-                // Neither worked — restore and keep the expression result
-                restoreLex(P.L, exprSave);
-                expr = parseTestExpr(P, closer);
-            }
-            skipBlanks(P.L);
-        }
-        const closeTok = nextToken(P.L, 'arg');
-        let close;
-        if (closeTok.value === closer) {
-            close = leaf(P, closer, closeTok);
-        }
-        else {
-            close = mk(P, closer, open.endIndex, open.endIndex, []);
-        }
-        const kids = expr ? [open, expr, close] : [open, close];
-        return mk(P, 'test_command', open.startIndex, close.endIndex, kids);
-    }
-    if (t.type === 'WORD') {
-        if (t.value === 'if')
-            return maybeRedirect(P, parseIf(P, t), true);
-        if (t.value === 'while' || t.value === 'until')
-            return maybeRedirect(P, parseWhile(P, t), true);
-        if (t.value === 'for')
-            return maybeRedirect(P, parseFor(P, t), true);
-        if (t.value === 'select')
-            return maybeRedirect(P, parseFor(P, t), true);
-        if (t.value === 'case')
-            return maybeRedirect(P, parseCase(P, t), true);
-        if (t.value === 'function')
-            return parseFunction(P, t);
-        if (DECL_KEYWORDS.has(t.value))
-            return maybeRedirect(P, parseDeclaration(P, t));
-        if (t.value === 'unset' || t.value === 'unsetenv') {
-            return maybeRedirect(P, parseUnset(P, t));
-        }
-    }
-    restoreLex(P.L, save);
-    return parseSimpleCommand(P);
-}
-/**
- * Parse a simple command: [assignment]* word [arg|redirect]*
- * Returns variable_assignment if only one assignment and no command.
- */
-function parseSimpleCommand(P) {
-    const start = P.L.b;
-    const assignments = [];
-    const preRedirects = [];
-    while (true) {
-        skipBlanks(P.L);
-        const a = tryParseAssignment(P);
-        if (a) {
-            assignments.push(a);
-            continue;
-        }
-        const r = tryParseRedirect(P);
-        if (r) {
-            preRedirects.push(r);
-            continue;
-        }
-        break;
-    }
-    skipBlanks(P.L);
-    const save = saveLex(P.L);
-    const nameTok = nextToken(P.L, 'cmd');
-    if (nameTok.type === 'EOF' ||
-        nameTok.type === 'NEWLINE' ||
-        nameTok.type === 'COMMENT' ||
-        (nameTok.type === 'OP' &&
-            nameTok.value !== '{' &&
-            nameTok.value !== '[' &&
-            nameTok.value !== '[[') ||
-        (nameTok.type === 'WORD' &&
-            SHELL_KEYWORDS.has(nameTok.value) &&
-            nameTok.value !== 'in')) {
-        restoreLex(P.L, save);
-        // No command — standalone assignment(s) or redirect
-        if (assignments.length === 1 && preRedirects.length === 0) {
-            return assignments[0];
-        }
-        if (preRedirects.length > 0 && assignments.length === 0) {
-            // Bare redirect → redirected_statement with just file_redirect children
-            const last = preRedirects[preRedirects.length - 1];
-            return mk(P, 'redirected_statement', preRedirects[0].startIndex, last.endIndex, preRedirects);
-        }
-        if (assignments.length > 1 && preRedirects.length === 0) {
-            // `A=1 B=2` with no command → variable_assignments (plural)
-            const last = assignments[assignments.length - 1];
-            return mk(P, 'variable_assignments', assignments[0].startIndex, last.endIndex, assignments);
-        }
-        if (assignments.length > 0 || preRedirects.length > 0) {
-            const all = [...assignments, ...preRedirects];
-            const last = all[all.length - 1];
-            return mk(P, 'command', start, last.endIndex, all);
-        }
-        return null;
-    }
-    restoreLex(P.L, save);
-    // Check for function definition: name() { ... }
-    const fnSave = saveLex(P.L);
-    const nm = parseWord(P, 'cmd');
-    if (nm && nm.type === 'word') {
-        skipBlanks(P.L);
-        if (peek(P.L) === '(' && peek(P.L, 1) === ')') {
-            const oTok = nextToken(P.L, 'cmd');
-            const cTok = nextToken(P.L, 'cmd');
-            const oParen = leaf(P, '(', oTok);
-            const cParen = leaf(P, ')', cTok);
-            skipBlanks(P.L);
-            skipNewlines(P);
-            const body = parseCommand(P);
-            if (body) {
-                // If body is redirected_statement(compound_statement, file_redirect...),
-                // hoist redirects to function_definition level per tree-sitter grammar
-                let bodyKids = [body];
-                if (body.type === 'redirected_statement' &&
-                    body.children.length >= 2 &&
-                    body.children[0].type === 'compound_statement') {
-                    bodyKids = body.children;
-                }
-                const last = bodyKids[bodyKids.length - 1];
-                return mk(P, 'function_definition', nm.startIndex, last.endIndex, [
-                    nm,
-                    oParen,
-                    cParen,
-                    ...bodyKids,
-                ]);
-            }
-        }
-    }
-    restoreLex(P.L, fnSave);
-    const nameArg = parseWord(P, 'cmd');
-    if (!nameArg) {
-        if (assignments.length === 1)
-            return assignments[0];
-        return null;
-    }
-    const cmdName = mk(P, 'command_name', nameArg.startIndex, nameArg.endIndex, [
-        nameArg,
-    ]);
-    const args = [];
-    const redirects = [];
-    let heredocRedirect = null;
-    while (true) {
-        skipBlanks(P.L);
-        // Post-command redirects are greedy (repeat1 $._literal) — once a redirect
-        // appears after command_name, subsequent literals attach to it per grammar's
-        // prec.left. `grep 2>/dev/null -q foo` → file_redirect eats `-q foo`.
-        // Args parsed BEFORE the first redirect still go to command (cat a b > out).
-        const r = tryParseRedirect(P, true);
-        if (r) {
-            if (r.type === 'heredoc_redirect') {
-                heredocRedirect = r;
-            }
-            else if (r.type === 'herestring_redirect') {
-                args.push(r);
-            }
-            else {
-                redirects.push(r);
-            }
-            continue;
-        }
-        // Once a file_redirect has been seen, command args are done — grammar's
-        // command rule doesn't allow file_redirect in its post-name choice, so
-        // anything after belongs to redirected_statement's file_redirect children.
-        if (redirects.length > 0)
-            break;
-        // `[` test_command backtrack — stop at `]` so outer handler can consume it
-        if (P.stopToken === ']' && peek(P.L) === ']')
-            break;
-        const save2 = saveLex(P.L);
-        const pk = nextToken(P.L, 'arg');
-        if (pk.type === 'EOF' ||
-            pk.type === 'NEWLINE' ||
-            pk.type === 'COMMENT' ||
-            (pk.type === 'OP' &&
-                (pk.value === '|' ||
-                    pk.value === '|&' ||
-                    pk.value === '&&' ||
-                    pk.value === '||' ||
-                    pk.value === ';' ||
-                    pk.value === ';;' ||
-                    pk.value === ';&' ||
-                    pk.value === ';;&' ||
-                    pk.value === '&' ||
-                    pk.value === ')' ||
-                    pk.value === '}' ||
-                    pk.value === '))'))) {
-            restoreLex(P.L, save2);
-            break;
-        }
-        restoreLex(P.L, save2);
-        const arg = parseWord(P, 'arg');
-        if (!arg) {
-            // Lone `(` in arg position — tree-sitter parses this as subshell arg
-            // e.g., `echo =(cmd)` → command has ERROR(=), subshell(cmd) as args
-            if (peek(P.L) === '(') {
-                const oTok = nextToken(P.L, 'cmd');
-                const open = leaf(P, '(', oTok);
-                const body = parseStatements(P, ')');
-                const cTok = nextToken(P.L, 'cmd');
-                const close = cTok.type === 'OP' && cTok.value === ')'
-                    ? leaf(P, ')', cTok)
-                    : mk(P, ')', open.endIndex, open.endIndex, []);
-                args.push(mk(P, 'subshell', open.startIndex, close.endIndex, [
-                    open,
-                    ...body,
-                    close,
-                ]));
-                continue;
-            }
-            break;
-        }
-        // Lone `=` in arg position is a parse error in bash — tree-sitter wraps
-        // it in ERROR for recovery. Happens in `echo =(cmd)` (zsh process-sub).
-        if (arg.type === 'word' && arg.text === '=') {
-            args.push(mk(P, 'ERROR', arg.startIndex, arg.endIndex, [arg]));
-            continue;
-        }
-        // Word immediately followed by `(` (no whitespace) is a parse error —
-        // bash doesn't allow glob-then-subshell adjacency. tree-sitter wraps the
-        // word in ERROR. Catches zsh glob qualifiers like `*.(e:'cmd':)`.
-        if ((arg.type === 'word' || arg.type === 'concatenation') &&
-            peek(P.L) === '(' &&
-            P.L.b === arg.endIndex) {
-            args.push(mk(P, 'ERROR', arg.startIndex, arg.endIndex, [arg]));
-            continue;
-        }
-        args.push(arg);
-    }
-    // preRedirects (e.g., `2>&1 cat`, `<<<str cmd`) go INSIDE the command node
-    // before command_name per tree-sitter grammar, not in redirected_statement
-    const cmdChildren = [...assignments, ...preRedirects, cmdName, ...args];
-    const cmdEnd = cmdChildren.length > 0
-        ? cmdChildren[cmdChildren.length - 1].endIndex
-        : cmdName.endIndex;
-    const cmdStart = cmdChildren[0].startIndex;
-    const cmd = mk(P, 'command', cmdStart, cmdEnd, cmdChildren);
-    if (heredocRedirect) {
-        // Scan heredoc body now
-        scanHeredocBodies(P);
-        const hd = P.L.heredocs.shift();
-        if (hd && heredocRedirect.children.length >= 2) {
-            const bodyNode = mk(P, 'heredoc_body', hd.bodyStart, hd.bodyEnd, hd.quoted ? [] : parseHeredocBodyContent(P, hd.bodyStart, hd.bodyEnd));
-            const endNode = mk(P, 'heredoc_end', hd.endStart, hd.endEnd, []);
-            heredocRedirect.children.push(bodyNode, endNode);
-            heredocRedirect.endIndex = hd.endEnd;
-            heredocRedirect.text = sliceBytes(P, heredocRedirect.startIndex, hd.endEnd);
-        }
-        const allR = [...preRedirects, heredocRedirect, ...redirects];
-        const rStart = preRedirects.length > 0
-            ? Math.min(cmd.startIndex, preRedirects[0].startIndex)
-            : cmd.startIndex;
-        return mk(P, 'redirected_statement', rStart, heredocRedirect.endIndex, [
-            cmd,
-            ...allR,
-        ]);
-    }
-    if (redirects.length > 0) {
-        const last = redirects[redirects.length - 1];
-        return mk(P, 'redirected_statement', cmd.startIndex, last.endIndex, [
-            cmd,
-            ...redirects,
-        ]);
-    }
-    return cmd;
-}
-function maybeRedirect(P, node, allowHerestring = false) {
-    const redirects = [];
-    while (true) {
-        skipBlanks(P.L);
-        const save = saveLex(P.L);
-        const r = tryParseRedirect(P);
-        if (!r)
-            break;
-        if (r.type === 'herestring_redirect' && !allowHerestring) {
-            restoreLex(P.L, save);
-            break;
-        }
-        redirects.push(r);
-    }
-    if (redirects.length === 0)
-        return node;
-    const last = redirects[redirects.length - 1];
-    return mk(P, 'redirected_statement', node.startIndex, last.endIndex, [
-        node,
-        ...redirects,
-    ]);
-}
-function tryParseAssignment(P) {
-    const save = saveLex(P.L);
-    skipBlanks(P.L);
-    const startB = P.L.b;
-    // Must start with identifier
-    if (!isIdentStart(peek(P.L))) {
-        restoreLex(P.L, save);
-        return null;
-    }
-    while (isIdentChar(peek(P.L)))
-        advance(P.L);
-    const nameEnd = P.L.b;
-    // Optional subscript
-    let subEnd = nameEnd;
-    if (peek(P.L) === '[') {
-        advance(P.L);
-        let depth = 1;
-        while (P.L.i < P.L.len && depth > 0) {
-            const c = peek(P.L);
-            if (c === '[')
-                depth++;
-            else if (c === ']')
-                depth--;
-            advance(P.L);
-        }
-        subEnd = P.L.b;
-    }
-    const c = peek(P.L);
-    const c1 = peek(P.L, 1);
-    let op;
-    if (c === '=' && c1 !== '=') {
-        op = '=';
-    }
-    else if (c === '+' && c1 === '=') {
-        op = '+=';
-    }
-    else {
-        restoreLex(P.L, save);
-        return null;
-    }
-    const nameNode = mk(P, 'variable_name', startB, nameEnd, []);
-    // Subscript handling: wrap in subscript node if present
-    let lhs = nameNode;
-    if (subEnd > nameEnd) {
-        const brOpen = mk(P, '[', nameEnd, nameEnd + 1, []);
-        const idx = parseSubscriptIndex(P, nameEnd + 1, subEnd - 1);
-        const brClose = mk(P, ']', subEnd - 1, subEnd, []);
-        lhs = mk(P, 'subscript', startB, subEnd, [nameNode, brOpen, idx, brClose]);
-    }
-    const opStart = P.L.b;
-    advance(P.L);
-    if (op === '+=')
-        advance(P.L);
-    const opEnd = P.L.b;
-    const opNode = mk(P, op, opStart, opEnd, []);
-    let val = null;
-    if (peek(P.L) === '(') {
-        // Array
-        const aoTok = nextToken(P.L, 'cmd');
-        const aOpen = leaf(P, '(', aoTok);
-        const elems = [aOpen];
-        while (true) {
-            skipBlanks(P.L);
-            if (peek(P.L) === ')')
-                break;
-            const e = parseWord(P, 'arg');
-            if (!e)
-                break;
-            elems.push(e);
-        }
-        const acTok = nextToken(P.L, 'cmd');
-        const aClose = acTok.value === ')'
-            ? leaf(P, ')', acTok)
-            : mk(P, ')', aOpen.endIndex, aOpen.endIndex, []);
-        elems.push(aClose);
-        val = mk(P, 'array', aOpen.startIndex, aClose.endIndex, elems);
-    }
-    else {
-        const c2 = peek(P.L);
-        if (c2 &&
-            c2 !== ' ' &&
-            c2 !== '\t' &&
-            c2 !== '\n' &&
-            c2 !== ';' &&
-            c2 !== '&' &&
-            c2 !== '|' &&
-            c2 !== ')' &&
-            c2 !== '}') {
-            val = parseWord(P, 'arg');
-        }
-    }
-    const kids = val ? [lhs, opNode, val] : [lhs, opNode];
-    const end = val ? val.endIndex : opEnd;
-    return mk(P, 'variable_assignment', startB, end, kids);
-}
-/**
- * Parse subscript index content. Parsed arithmetically per tree-sitter grammar:
- * `${a[1+2]}` → binary_expression; `${a[++i]}` → unary_expression(word);
- * `${a[(($n+1))]}` → compound_statement(binary_expression). Falls back to
- * simple patterns (@, *) as word.
- */
-function parseSubscriptIndexInline(P) {
-    skipBlanks(P.L);
-    const c = peek(P.L);
-    // @ or * alone → word (associative array all-keys)
-    if ((c === '@' || c === '*') && peek(P.L, 1) === ']') {
-        const s = P.L.b;
-        advance(P.L);
-        return mk(P, 'word', s, P.L.b, []);
-    }
-    // ((expr)) → compound_statement wrapping the inner arithmetic
-    if (c === '(' && peek(P.L, 1) === '(') {
-        const oStart = P.L.b;
-        advance(P.L);
-        advance(P.L);
-        const open = mk(P, '((', oStart, P.L.b, []);
-        const inner = parseArithExpr(P, '))', 'var');
-        skipBlanks(P.L);
-        let close;
-        if (peek(P.L) === ')' && peek(P.L, 1) === ')') {
-            const cs = P.L.b;
-            advance(P.L);
-            advance(P.L);
-            close = mk(P, '))', cs, P.L.b, []);
-        }
-        else {
-            close = mk(P, '))', P.L.b, P.L.b, []);
-        }
-        const kids = inner ? [open, inner, close] : [open, close];
-        return mk(P, 'compound_statement', open.startIndex, close.endIndex, kids);
-    }
-    // Arithmetic — but bare identifiers in subscript use 'word' mode per
-    // tree-sitter (${words[++counter]} → unary_expression(word)).
-    return parseArithExpr(P, ']', 'word');
-}
-/** Legacy byte-range subscript index parser — kept for callers that pre-scan. */
-function parseSubscriptIndex(P, startB, endB) {
-    const text = sliceBytes(P, startB, endB);
-    if (/^\d+$/.test(text))
-        return mk(P, 'number', startB, endB, []);
-    const m = /^\$([a-zA-Z_]\w*)$/.exec(text);
-    if (m) {
-        const dollar = mk(P, '$', startB, startB + 1, []);
-        const vn = mk(P, 'variable_name', startB + 1, endB, []);
-        return mk(P, 'simple_expansion', startB, endB, [dollar, vn]);
-    }
-    if (text.length === 2 && text[0] === '$' && SPECIAL_VARS.has(text[1])) {
-        const dollar = mk(P, '$', startB, startB + 1, []);
-        const vn = mk(P, 'special_variable_name', startB + 1, endB, []);
-        return mk(P, 'simple_expansion', startB, endB, [dollar, vn]);
-    }
-    return mk(P, 'word', startB, endB, []);
-}
-/**
- * Can the current position start a redirect destination literal?
- * Returns false at redirect ops, terminators, or file-descriptor-prefixed ops
- * so file_redirect's repeat1($._literal) stops at the right boundary.
- */
-function isRedirectLiteralStart(P) {
-    const c = peek(P.L);
-    if (c === '' || c === '\n')
-        return false;
-    // Shell terminators and operators
-    if (c === '|' || c === '&' || c === ';' || c === '(' || c === ')')
-        return false;
-    // Redirect operators (< > with any suffix; <( >( handled by caller)
-    if (c === '<' || c === '>') {
-        // <( >( are process substitutions — those ARE literals
-        return peek(P.L, 1) === '(';
-    }
-    // N< N> file descriptor prefix — starts a new redirect, not a literal
-    if (isDigit(c)) {
-        let j = P.L.i;
-        while (j < P.L.len && isDigit(P.L.src[j]))
-            j++;
-        const after = j < P.L.len ? P.L.src[j] : '';
-        if (after === '>' || after === '<')
-            return false;
-    }
-    // `}` only terminates if we're in a context where it's a closer — but
-    // file_redirect sees `}` as word char (e.g., `>$HOME}` is valid path char).
-    // Actually `}` at top level terminates compound_statement — need to stop.
-    if (c === '}')
-        return false;
-    // Test command closer — when parseSimpleCommand is called from `[` context,
-    // `]` must terminate so parseCommand can return and `[` handler consume it.
-    if (P.stopToken === ']' && c === ']')
-        return false;
-    return true;
-}
-/**
- * Parse a redirect operator + destination(s).
- * @param greedy When true, file_redirect consumes repeat1($._literal) per
- *   grammar's prec.left — `cmd >f a b c` attaches `a b c` to the redirect.
- *   When false (preRedirect context), takes only 1 destination because
- *   command's dynamic precedence beats redirected_statement's prec(-1).
- */
-function tryParseRedirect(P, greedy = false) {
-    const save = saveLex(P.L);
-    skipBlanks(P.L);
-    // File descriptor prefix?
-    let fd = null;
-    if (isDigit(peek(P.L))) {
-        const startB = P.L.b;
-        let j = P.L.i;
-        while (j < P.L.len && isDigit(P.L.src[j]))
-            j++;
-        const after = j < P.L.len ? P.L.src[j] : '';
-        if (after === '>' || after === '<') {
-            while (P.L.i < j)
-                advance(P.L);
-            fd = mk(P, 'file_descriptor', startB, P.L.b, []);
-        }
-    }
-    const t = nextToken(P.L, 'arg');
-    if (t.type !== 'OP') {
-        restoreLex(P.L, save);
-        return null;
-    }
-    const v = t.value;
-    if (v === '<<<') {
-        const op = leaf(P, '<<<', t);
-        skipBlanks(P.L);
-        const target = parseWord(P, 'arg');
-        const end = target ? target.endIndex : op.endIndex;
-        const kids = target ? [op, target] : [op];
-        return mk(P, 'herestring_redirect', fd ? fd.startIndex : op.startIndex, end, fd ? [fd, ...kids] : kids);
-    }
-    if (v === '<<' || v === '<<-') {
-        const op = leaf(P, v, t);
-        // Heredoc start — delimiter word (may be quoted)
-        skipBlanks(P.L);
-        const dStart = P.L.b;
-        let quoted = false;
-        let delim = '';
-        const dc = peek(P.L);
-        if (dc === "'" || dc === '"') {
-            quoted = true;
-            advance(P.L);
-            while (P.L.i < P.L.len && peek(P.L) !== dc) {
-                delim += peek(P.L);
-                advance(P.L);
-            }
-            if (P.L.i < P.L.len)
-                advance(P.L);
-        }
-        else if (dc === '\\') {
-            // Backslash-escaped delimiter: \X — exactly one escaped char, body is
-            // quoted (literal). Covers <<\EOF <<\' <<\\ etc.
-            quoted = true;
-            advance(P.L);
-            if (P.L.i < P.L.len && peek(P.L) !== '\n') {
-                delim += peek(P.L);
-                advance(P.L);
-            }
-            // May be followed by more ident chars (e.g. <<\EOF → delim "EOF")
-            while (P.L.i < P.L.len && isIdentChar(peek(P.L))) {
-                delim += peek(P.L);
-                advance(P.L);
-            }
-        }
-        else {
-            // Unquoted delimiter: bash accepts most non-metacharacters (not just
-            // identifiers). Allow !, -, ., etc. — stop at shell metachars.
-            while (P.L.i < P.L.len && isHeredocDelimChar(peek(P.L))) {
-                delim += peek(P.L);
-                advance(P.L);
-            }
-        }
-        const dEnd = P.L.b;
-        const startNode = mk(P, 'heredoc_start', dStart, dEnd, []);
-        // Register pending heredoc — body scanned at next newline
-        P.L.heredocs.push({
-            delim,
-            stripTabs: v === '<<-',
-            quoted,
-            bodyStart: 0,
-            bodyEnd: 0,
-            endStart: 0,
-            endEnd: 0,
-        });
-        const kids = fd ? [fd, op, startNode] : [op, startNode];
-        const startIdx = fd ? fd.startIndex : op.startIndex;
-        // SECURITY: tree-sitter nests any pipeline/list/file_redirect appearing
-        // between heredoc_start and the newline as a CHILD of heredoc_redirect.
-        // `ls <<'EOF' | rm -rf /tmp/evil` must not silently drop the rm. Parse
-        // trailing words and file_redirects properly (ast.ts walkHeredocRedirect
-        // fails closed on any unrecognized child via tooComplex). Pipeline / list
-        // operators (| && || ;) are structurally complex — emit ERROR so the same
-        // fail-closed path rejects them.
-        while (true) {
-            skipBlanks(P.L);
-            const tc = peek(P.L);
-            if (tc === '\n' || tc === '' || P.L.i >= P.L.len)
-                break;
-            // File redirect after delimiter: cat <<EOF > out.txt
-            if (tc === '>' || tc === '<' || isDigit(tc)) {
-                const rSave = saveLex(P.L);
-                const r = tryParseRedirect(P);
-                if (r && r.type === 'file_redirect') {
-                    kids.push(r);
-                    continue;
-                }
-                restoreLex(P.L, rSave);
-            }
-            // Pipeline after heredoc_start: `one <<EOF | grep two` — tree-sitter
-            // nests the pipeline as a child of heredoc_redirect. ast.ts
-            // walkHeredocRedirect fails closed on pipeline/command via tooComplex.
-            if (tc === '|' && peek(P.L, 1) !== '|') {
-                advance(P.L);
-                skipBlanks(P.L);
-                const pipeCmds = [];
-                while (true) {
-                    const cmd = parseCommand(P);
-                    if (!cmd)
-                        break;
-                    pipeCmds.push(cmd);
-                    skipBlanks(P.L);
-                    if (peek(P.L) === '|' && peek(P.L, 1) !== '|') {
-                        const ps = P.L.b;
-                        advance(P.L);
-                        pipeCmds.push(mk(P, '|', ps, P.L.b, []));
-                        skipBlanks(P.L);
-                        continue;
-                    }
-                    break;
-                }
-                if (pipeCmds.length > 0) {
-                    const pl = pipeCmds[pipeCmds.length - 1];
-                    // tree-sitter always wraps in pipeline after `|`, even single command
-                    kids.push(mk(P, 'pipeline', pipeCmds[0].startIndex, pl.endIndex, pipeCmds));
-                }
-                continue;
-            }
-            // && / || after heredoc_start: `cat <<-EOF || die "..."` — tree-sitter
-            // nests just the RHS command (not a list) as a child of heredoc_redirect.
-            if ((tc === '&' && peek(P.L, 1) === '&') ||
-                (tc === '|' && peek(P.L, 1) === '|')) {
-                advance(P.L);
-                advance(P.L);
-                skipBlanks(P.L);
-                const rhs = parseCommand(P);
-                if (rhs)
-                    kids.push(rhs);
-                continue;
-            }
-            // Terminator / unhandled metachar — consume rest of line as ERROR so
-            // ast.ts rejects it. Covers ; & ( )
-            if (tc === '&' || tc === ';' || tc === '(' || tc === ')') {
-                const eStart = P.L.b;
-                while (P.L.i < P.L.len && peek(P.L) !== '\n')
-                    advance(P.L);
-                kids.push(mk(P, 'ERROR', eStart, P.L.b, []));
-                break;
-            }
-            // Trailing word argument: newins <<-EOF - org.freedesktop.service
-            const w = parseWord(P, 'arg');
-            if (w) {
-                kids.push(w);
-                continue;
-            }
-            // Unrecognized — consume rest of line as ERROR
-            const eStart = P.L.b;
-            while (P.L.i < P.L.len && peek(P.L) !== '\n')
-                advance(P.L);
-            if (P.L.b > eStart)
-                kids.push(mk(P, 'ERROR', eStart, P.L.b, []));
-            break;
-        }
-        return mk(P, 'heredoc_redirect', startIdx, P.L.b, kids);
-    }
-    // Close-fd variants: `<&-` `>&-` have OPTIONAL destination (0 or 1)
-    if (v === '<&-' || v === '>&-') {
-        const op = leaf(P, v, t);
-        const kids = [];
-        if (fd)
-            kids.push(fd);
-        kids.push(op);
-        // Optional single destination — only consume if next is a literal
-        skipBlanks(P.L);
-        const dSave = saveLex(P.L);
-        const dest = isRedirectLiteralStart(P) ? parseWord(P, 'arg') : null;
-        if (dest) {
-            kids.push(dest);
-        }
-        else {
-            restoreLex(P.L, dSave);
-        }
-        const startIdx = fd ? fd.startIndex : op.startIndex;
-        const end = dest ? dest.endIndex : op.endIndex;
-        return mk(P, 'file_redirect', startIdx, end, kids);
-    }
-    if (v === '>' ||
-        v === '>>' ||
-        v === '>&' ||
-        v === '>|' ||
-        v === '&>' ||
-        v === '&>>' ||
-        v === '<' ||
-        v === '<&') {
-        const op = leaf(P, v, t);
-        const kids = [];
-        if (fd)
-            kids.push(fd);
-        kids.push(op);
-        // Grammar: destination is repeat1($._literal) — greedily consume literals
-        // until a non-literal (redirect op, terminator, etc). tree-sitter's
-        // prec.left makes `cmd >f a b c` attach `a b c` to the file_redirect,
-        // NOT to the command. Structural quirk but required for corpus parity.
-        // In preRedirect context (greedy=false), take only 1 literal because
-        // command's dynamic precedence beats redirected_statement's prec(-1).
-        let end = op.endIndex;
-        let taken = 0;
-        while (true) {
-            skipBlanks(P.L);
-            if (!isRedirectLiteralStart(P))
-                break;
-            if (!greedy && taken >= 1)
-                break;
-            const tc = peek(P.L);
-            const tc1 = peek(P.L, 1);
-            let target = null;
-            if ((tc === '<' || tc === '>') && tc1 === '(') {
-                target = parseProcessSub(P);
-            }
-            else {
-                target = parseWord(P, 'arg');
-            }
-            if (!target)
-                break;
-            kids.push(target);
-            end = target.endIndex;
-            taken++;
-        }
-        const startIdx = fd ? fd.startIndex : op.startIndex;
-        return mk(P, 'file_redirect', startIdx, end, kids);
-    }
-    restoreLex(P.L, save);
-    return null;
-}
-function parseProcessSub(P) {
-    const c = peek(P.L);
-    if ((c !== '<' && c !== '>') || peek(P.L, 1) !== '(')
-        return null;
-    const start = P.L.b;
-    advance(P.L);
-    advance(P.L);
-    const open = mk(P, c + '(', start, P.L.b, []);
-    const body = parseStatements(P, ')');
-    skipBlanks(P.L);
-    let close;
-    if (peek(P.L) === ')') {
-        const cs = P.L.b;
-        advance(P.L);
-        close = mk(P, ')', cs, P.L.b, []);
-    }
-    else {
-        close = mk(P, ')', P.L.b, P.L.b, []);
-    }
-    return mk(P, 'process_substitution', start, close.endIndex, [
-        open,
-        ...body,
-        close,
-    ]);
-}
-function scanHeredocBodies(P) {
-    // Skip to newline if not already there
-    while (P.L.i < P.L.len && P.L.src[P.L.i] !== '\n')
-        advance(P.L);
-    if (P.L.i < P.L.len)
-        advance(P.L);
-    for (const hd of P.L.heredocs) {
-        hd.bodyStart = P.L.b;
-        const delimLen = hd.delim.length;
-        while (P.L.i < P.L.len) {
-            const lineStart = P.L.i;
-            const lineStartB = P.L.b;
-            // Skip leading tabs if <<-
-            let checkI = lineStart;
-            if (hd.stripTabs) {
-                while (checkI < P.L.len && P.L.src[checkI] === '\t')
-                    checkI++;
-            }
-            // Check if this line is the delimiter
-            if (P.L.src.startsWith(hd.delim, checkI) &&
-                (checkI + delimLen >= P.L.len ||
-                    P.L.src[checkI + delimLen] === '\n' ||
-                    P.L.src[checkI + delimLen] === '\r')) {
-                hd.bodyEnd = lineStartB;
-                // Advance past tabs
-                while (P.L.i < checkI)
-                    advance(P.L);
-                hd.endStart = P.L.b;
-                // Advance past delimiter
-                for (let k = 0; k < delimLen; k++)
-                    advance(P.L);
-                hd.endEnd = P.L.b;
-                // Skip trailing newline
-                if (P.L.i < P.L.len && P.L.src[P.L.i] === '\n')
-                    advance(P.L);
-                return;
-            }
-            // Consume line
-            while (P.L.i < P.L.len && P.L.src[P.L.i] !== '\n')
-                advance(P.L);
-            if (P.L.i < P.L.len)
-                advance(P.L);
-        }
-        // Unterminated
-        hd.bodyEnd = P.L.b;
-        hd.endStart = P.L.b;
-        hd.endEnd = P.L.b;
-    }
-}
-function parseHeredocBodyContent(P, start, end) {
-    // Parse expansions inside an unquoted heredoc body.
-    const saved = saveLex(P.L);
-    // Position lexer at body start
-    restoreLexToByte(P, start);
-    const out = [];
-    let contentStart = P.L.b;
-    // tree-sitter-bash's heredoc_body rule hides the initial text segment
-    // (_heredoc_body_beginning) — only content AFTER the first expansion is
-    // emitted as heredoc_content. Track whether we've seen an expansion yet.
-    let sawExpansion = false;
-    while (P.L.b < end) {
-        const c = peek(P.L);
-        // Backslash escapes suppress expansion: \$ \` stay literal in heredoc.
-        if (c === '\\') {
-            const nxt = peek(P.L, 1);
-            if (nxt === '$' || nxt === '`' || nxt === '\\') {
-                advance(P.L);
-                advance(P.L);
-                continue;
-            }
-            advance(P.L);
-            continue;
-        }
-        if (c === '$' || c === '`') {
-            const preB = P.L.b;
-            const exp = parseDollarLike(P);
-            // Bare `$` followed by non-name (e.g. `$'` in a regex) returns a lone
-            // '$' leaf, not an expansion — treat as literal content, don't split.
-            if (exp &&
-                (exp.type === 'simple_expansion' ||
-                    exp.type === 'expansion' ||
-                    exp.type === 'command_substitution' ||
-                    exp.type === 'arithmetic_expansion')) {
-                if (sawExpansion && preB > contentStart) {
-                    out.push(mk(P, 'heredoc_content', contentStart, preB, []));
-                }
-                out.push(exp);
-                contentStart = P.L.b;
-                sawExpansion = true;
-            }
-            continue;
-        }
-        advance(P.L);
-    }
-    // Only emit heredoc_content children if there were expansions — otherwise
-    // the heredoc_body is a leaf node (tree-sitter convention).
-    if (sawExpansion) {
-        out.push(mk(P, 'heredoc_content', contentStart, end, []));
-    }
-    restoreLex(P.L, saved);
-    return out;
-}
-function restoreLexToByte(P, targetByte) {
-    if (!P.L.byteTable)
-        byteAt(P.L, 0);
-    const t = P.L.byteTable;
-    let lo = 0;
-    let hi = P.src.length;
-    while (lo < hi) {
-        const m = (lo + hi) >>> 1;
-        if (t[m] < targetByte)
-            lo = m + 1;
-        else
-            hi = m;
-    }
-    P.L.i = lo;
-    P.L.b = targetByte;
-}
-/**
- * Parse a word-position element: bare word, string, expansion, or concatenation
- * thereof. Returns a single node; if multiple adjacent fragments, wraps in
- * concatenation.
- */
-function parseWord(P, _ctx) {
-    skipBlanks(P.L);
-    const parts = [];
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === ' ' ||
-            c === '\t' ||
-            c === '\n' ||
-            c === '\r' ||
-            c === '' ||
-            c === '|' ||
-            c === '&' ||
-            c === ';' ||
-            c === '(' ||
-            c === ')') {
-            break;
-        }
-        // < > are redirect operators unless <( >( (process substitution)
-        if (c === '<' || c === '>') {
-            if (peek(P.L, 1) === '(') {
-                const ps = parseProcessSub(P);
-                if (ps)
-                    parts.push(ps);
-                continue;
-            }
-            break;
-        }
-        if (c === '"') {
-            parts.push(parseDoubleQuoted(P));
-            continue;
-        }
-        if (c === "'") {
-            const tok = nextToken(P.L, 'arg');
-            parts.push(leaf(P, 'raw_string', tok));
-            continue;
-        }
-        if (c === '$') {
-            const c1 = peek(P.L, 1);
-            if (c1 === "'") {
-                const tok = nextToken(P.L, 'arg');
-                parts.push(leaf(P, 'ansi_c_string', tok));
-                continue;
-            }
-            if (c1 === '"') {
-                // Translated string: emit $ leaf + string node
-                const dTok = {
-                    type: 'DOLLAR',
-                    value: '$',
-                    start: P.L.b,
-                    end: P.L.b + 1,
-                };
-                advance(P.L);
-                parts.push(leaf(P, '$', dTok));
-                parts.push(parseDoubleQuoted(P));
-                continue;
-            }
-            if (c1 === '`') {
-                // `$` followed by backtick — tree-sitter elides the $ entirely
-                // and emits just (command_substitution). Consume $ and let next
-                // iteration handle the backtick.
-                advance(P.L);
-                continue;
-            }
-            const exp = parseDollarLike(P);
-            if (exp)
-                parts.push(exp);
-            continue;
-        }
-        if (c === '`') {
-            if (P.inBacktick > 0)
-                break;
-            const bt = parseBacktick(P);
-            if (bt)
-                parts.push(bt);
-            continue;
-        }
-        // Brace expression {1..5} or {a,b,c} — only if looks like one
-        if (c === '{') {
-            const be = tryParseBraceExpr(P);
-            if (be) {
-                parts.push(be);
-                continue;
-            }
-            // SECURITY: if `{` is immediately followed by a command terminator
-            // (; | & newline or EOF), it's a standalone word — don't slurp the
-            // rest of the line via tryParseBraceLikeCat. `echo {;touch /tmp/evil`
-            // must split on `;` so the security walker sees `touch`.
-            const nc = peek(P.L, 1);
-            if (nc === ';' ||
-                nc === '|' ||
-                nc === '&' ||
-                nc === '\n' ||
-                nc === '' ||
-                nc === ')' ||
-                nc === ' ' ||
-                nc === '\t') {
-                const bStart = P.L.b;
-                advance(P.L);
-                parts.push(mk(P, 'word', bStart, P.L.b, []));
-                continue;
-            }
-            // Otherwise treat { and } as word fragments
-            const cat = tryParseBraceLikeCat(P);
-            if (cat) {
-                for (const p of cat)
-                    parts.push(p);
-                continue;
-            }
-        }
-        // Standalone `}` in arg position is a word (e.g., `echo }foo`).
-        // parseBareWord breaks on `}` so handle it here.
-        if (c === '}') {
-            const bStart = P.L.b;
-            advance(P.L);
-            parts.push(mk(P, 'word', bStart, P.L.b, []));
-            continue;
-        }
-        // `[` and `]` are single-char word fragments (tree-sitter splits at
-        // brackets: `[:lower:]` → `[` `:lower:` `]`, `{o[k]}` → 6 words).
-        if (c === '[' || c === ']') {
-            const bStart = P.L.b;
-            advance(P.L);
-            parts.push(mk(P, 'word', bStart, P.L.b, []));
-            continue;
-        }
-        // Bare word fragment
-        const frag = parseBareWord(P);
-        if (!frag)
-            break;
-        // `NN#${...}` or `NN#$(...)` → (number (expansion|command_substitution)).
-        // Grammar: number can be seq(/-?(0x)?[0-9]+#/, choice(expansion, cmd_sub)).
-        // `10#${cmd}` must NOT be concatenation — it's a single number node with
-        // the expansion as child. Detect here: frag ends with `#`, next is $ {/(.
-        if (frag.type === 'word' &&
-            /^-?(0x)?[0-9]+#$/.test(frag.text) &&
-            peek(P.L) === '$' &&
-            (peek(P.L, 1) === '{' || peek(P.L, 1) === '(')) {
-            const exp = parseDollarLike(P);
-            if (exp) {
-                // Prefix `NN#` is an anonymous pattern in grammar — only the
-                // expansion/cmd_sub is a named child.
-                parts.push(mk(P, 'number', frag.startIndex, exp.endIndex, [exp]));
-                continue;
-            }
-        }
-        parts.push(frag);
-    }
-    if (parts.length === 0)
-        return null;
-    if (parts.length === 1)
-        return parts[0];
-    // Concatenation
-    const first = parts[0];
-    const last = parts[parts.length - 1];
-    return mk(P, 'concatenation', first.startIndex, last.endIndex, parts);
-}
-function parseBareWord(P) {
-    const start = P.L.b;
-    const startI = P.L.i;
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '\\') {
-            if (P.L.i + 1 >= P.L.len) {
-                // Trailing unpaired `\` at true EOF — tree-sitter emits word WITHOUT
-                // the `\` plus a sibling ERROR node. Stop here; caller emits ERROR.
-                break;
-            }
-            const nx = P.L.src[P.L.i + 1];
-            if (nx === '\n' || (nx === '\r' && P.L.src[P.L.i + 2] === '\n')) {
-                // Line continuation BREAKS the word (tree-sitter quirk) — handles \r?\n
-                break;
-            }
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        if (c === ' ' ||
-            c === '\t' ||
-            c === '\n' ||
-            c === '\r' ||
-            c === '' ||
-            c === '|' ||
-            c === '&' ||
-            c === ';' ||
-            c === '(' ||
-            c === ')' ||
-            c === '<' ||
-            c === '>' ||
-            c === '"' ||
-            c === "'" ||
-            c === '$' ||
-            c === '`' ||
-            c === '{' ||
-            c === '}' ||
-            c === '[' ||
-            c === ']') {
-            break;
-        }
-        advance(P.L);
-    }
-    if (P.L.b === start)
-        return null;
-    const text = P.src.slice(startI, P.L.i);
-    const type = /^-?\d+$/.test(text) ? 'number' : 'word';
-    return mk(P, type, start, P.L.b, []);
-}
-function tryParseBraceExpr(P) {
-    // {N..M} where N, M are numbers or single chars
-    const save = saveLex(P.L);
-    if (peek(P.L) !== '{')
-        return null;
-    const oStart = P.L.b;
-    advance(P.L);
-    const oEnd = P.L.b;
-    // First part
-    const p1Start = P.L.b;
-    while (isDigit(peek(P.L)) || isIdentStart(peek(P.L)))
-        advance(P.L);
-    const p1End = P.L.b;
-    if (p1End === p1Start || peek(P.L) !== '.' || peek(P.L, 1) !== '.') {
-        restoreLex(P.L, save);
-        return null;
-    }
-    const dotStart = P.L.b;
-    advance(P.L);
-    advance(P.L);
-    const dotEnd = P.L.b;
-    const p2Start = P.L.b;
-    while (isDigit(peek(P.L)) || isIdentStart(peek(P.L)))
-        advance(P.L);
-    const p2End = P.L.b;
-    if (p2End === p2Start || peek(P.L) !== '}') {
-        restoreLex(P.L, save);
-        return null;
-    }
-    const cStart = P.L.b;
-    advance(P.L);
-    const cEnd = P.L.b;
-    const p1Text = sliceBytes(P, p1Start, p1End);
-    const p2Text = sliceBytes(P, p2Start, p2End);
-    const p1IsNum = /^\d+$/.test(p1Text);
-    const p2IsNum = /^\d+$/.test(p2Text);
-    // Valid brace expression: both numbers OR both single chars. Mixed = reject.
-    if (p1IsNum !== p2IsNum) {
-        restoreLex(P.L, save);
-        return null;
-    }
-    if (!p1IsNum && (p1Text.length !== 1 || p2Text.length !== 1)) {
-        restoreLex(P.L, save);
-        return null;
-    }
-    const p1Type = p1IsNum ? 'number' : 'word';
-    const p2Type = p2IsNum ? 'number' : 'word';
-    return mk(P, 'brace_expression', oStart, cEnd, [
-        mk(P, '{', oStart, oEnd, []),
-        mk(P, p1Type, p1Start, p1End, []),
-        mk(P, '..', dotStart, dotEnd, []),
-        mk(P, p2Type, p2Start, p2End, []),
-        mk(P, '}', cStart, cEnd, []),
-    ]);
-}
-function tryParseBraceLikeCat(P) {
-    // {a,b,c} or {} → split into word fragments like tree-sitter does
-    if (peek(P.L) !== '{')
-        return null;
-    const oStart = P.L.b;
-    advance(P.L);
-    const oEnd = P.L.b;
-    const inner = [mk(P, 'word', oStart, oEnd, [])];
-    while (P.L.i < P.L.len) {
-        const bc = peek(P.L);
-        // SECURITY: stop at command terminators so `{foo;rm x` splits correctly.
-        if (bc === '}' ||
-            bc === '\n' ||
-            bc === ';' ||
-            bc === '|' ||
-            bc === '&' ||
-            bc === ' ' ||
-            bc === '\t' ||
-            bc === '<' ||
-            bc === '>' ||
-            bc === '(' ||
-            bc === ')') {
-            break;
-        }
-        // `[` and `]` are single-char words: {o[k]} → { o [ k ] }
-        if (bc === '[' || bc === ']') {
-            const bStart = P.L.b;
-            advance(P.L);
-            inner.push(mk(P, 'word', bStart, P.L.b, []));
-            continue;
-        }
-        const midStart = P.L.b;
-        while (P.L.i < P.L.len) {
-            const mc = peek(P.L);
-            if (mc === '}' ||
-                mc === '\n' ||
-                mc === ';' ||
-                mc === '|' ||
-                mc === '&' ||
-                mc === ' ' ||
-                mc === '\t' ||
-                mc === '<' ||
-                mc === '>' ||
-                mc === '(' ||
-                mc === ')' ||
-                mc === '[' ||
-                mc === ']') {
-                break;
-            }
-            advance(P.L);
-        }
-        const midEnd = P.L.b;
-        if (midEnd > midStart) {
-            const midText = sliceBytes(P, midStart, midEnd);
-            const midType = /^-?\d+$/.test(midText) ? 'number' : 'word';
-            inner.push(mk(P, midType, midStart, midEnd, []));
-        }
-        else {
-            break;
-        }
-    }
-    if (peek(P.L) === '}') {
-        const cStart = P.L.b;
-        advance(P.L);
-        inner.push(mk(P, 'word', cStart, P.L.b, []));
-    }
-    return inner;
-}
-function parseDoubleQuoted(P) {
-    const qStart = P.L.b;
-    advance(P.L);
-    const qEnd = P.L.b;
-    const openQ = mk(P, '"', qStart, qEnd, []);
-    const parts = [openQ];
-    let contentStart = P.L.b;
-    let contentStartI = P.L.i;
-    const flushContent = () => {
-        if (P.L.b > contentStart) {
-            // Tree-sitter's extras rule /\s/ has higher precedence than
-            // string_content (prec -1), so whitespace-only segments are elided.
-            // `" ${x} "` → (string (expansion)) not (string (string_content)(expansion)(string_content)).
-            // Note: this intentionally diverges from preserving all content — cc
-            // tests relying on whitespace-only string_content need updating
-            // (CCReconcile).
-            const txt = P.src.slice(contentStartI, P.L.i);
-            if (!/^[ \t]+$/.test(txt)) {
-                parts.push(mk(P, 'string_content', contentStart, P.L.b, []));
-            }
-        }
-    };
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '"')
-            break;
-        if (c === '\\' && P.L.i + 1 < P.L.len) {
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        if (c === '\n') {
-            // Split string_content at newline
-            flushContent();
-            advance(P.L);
-            contentStart = P.L.b;
-            contentStartI = P.L.i;
-            continue;
-        }
-        if (c === '$') {
-            const c1 = peek(P.L, 1);
-            if (c1 === '(' ||
-                c1 === '{' ||
-                isIdentStart(c1) ||
-                SPECIAL_VARS.has(c1) ||
-                isDigit(c1)) {
-                flushContent();
-                const exp = parseDollarLike(P);
-                if (exp)
-                    parts.push(exp);
-                contentStart = P.L.b;
-                contentStartI = P.L.i;
-                continue;
-            }
-            // Bare $ not at end-of-string: tree-sitter emits it as an anonymous
-            // '$' token, which splits string_content. $ immediately before the
-            // closing " is absorbed into the preceding string_content.
-            if (c1 !== '"' && c1 !== '') {
-                flushContent();
-                const dS = P.L.b;
-                advance(P.L);
-                parts.push(mk(P, '$', dS, P.L.b, []));
-                contentStart = P.L.b;
-                contentStartI = P.L.i;
-                continue;
-            }
-        }
-        if (c === '`') {
-            flushContent();
-            const bt = parseBacktick(P);
-            if (bt)
-                parts.push(bt);
-            contentStart = P.L.b;
-            contentStartI = P.L.i;
-            continue;
-        }
-        advance(P.L);
-    }
-    flushContent();
-    let close;
-    if (peek(P.L) === '"') {
-        const cStart = P.L.b;
-        advance(P.L);
-        close = mk(P, '"', cStart, P.L.b, []);
-    }
-    else {
-        close = mk(P, '"', P.L.b, P.L.b, []);
-    }
-    parts.push(close);
-    return mk(P, 'string', qStart, close.endIndex, parts);
-}
-function parseDollarLike(P) {
-    const c1 = peek(P.L, 1);
-    const dStart = P.L.b;
-    if (c1 === '(' && peek(P.L, 2) === '(') {
-        // $(( arithmetic ))
-        advance(P.L);
-        advance(P.L);
-        advance(P.L);
-        const open = mk(P, '$((', dStart, P.L.b, []);
-        const exprs = parseArithCommaList(P, '))', 'var');
-        skipBlanks(P.L);
-        let close;
-        if (peek(P.L) === ')' && peek(P.L, 1) === ')') {
-            const cStart = P.L.b;
-            advance(P.L);
-            advance(P.L);
-            close = mk(P, '))', cStart, P.L.b, []);
-        }
-        else {
-            close = mk(P, '))', P.L.b, P.L.b, []);
-        }
-        return mk(P, 'arithmetic_expansion', dStart, close.endIndex, [
-            open,
-            ...exprs,
-            close,
-        ]);
-    }
-    if (c1 === '[') {
-        // $[ arithmetic ] — legacy bash syntax, same as $((...))
-        advance(P.L);
-        advance(P.L);
-        const open = mk(P, '$[', dStart, P.L.b, []);
-        const exprs = parseArithCommaList(P, ']', 'var');
-        skipBlanks(P.L);
-        let close;
-        if (peek(P.L) === ']') {
-            const cStart = P.L.b;
-            advance(P.L);
-            close = mk(P, ']', cStart, P.L.b, []);
-        }
-        else {
-            close = mk(P, ']', P.L.b, P.L.b, []);
-        }
-        return mk(P, 'arithmetic_expansion', dStart, close.endIndex, [
-            open,
-            ...exprs,
-            close,
-        ]);
-    }
-    if (c1 === '(') {
-        advance(P.L);
-        advance(P.L);
-        const open = mk(P, '$(', dStart, P.L.b, []);
-        let body = parseStatements(P, ')');
-        skipBlanks(P.L);
-        let close;
-        if (peek(P.L) === ')') {
-            const cStart = P.L.b;
-            advance(P.L);
-            close = mk(P, ')', cStart, P.L.b, []);
-        }
-        else {
-            close = mk(P, ')', P.L.b, P.L.b, []);
-        }
-        // $(< file) shorthand: unwrap redirected_statement → bare file_redirect
-        // tree-sitter emits (command_substitution (file_redirect (word))) directly
-        if (body.length === 1 &&
-            body[0].type === 'redirected_statement' &&
-            body[0].children.length === 1 &&
-            body[0].children[0].type === 'file_redirect') {
-            body = body[0].children;
-        }
-        return mk(P, 'command_substitution', dStart, close.endIndex, [
-            open,
-            ...body,
-            close,
-        ]);
-    }
-    if (c1 === '{') {
-        advance(P.L);
-        advance(P.L);
-        const open = mk(P, '${', dStart, P.L.b, []);
-        const inner = parseExpansionBody(P);
-        let close;
-        if (peek(P.L) === '}') {
-            const cStart = P.L.b;
-            advance(P.L);
-            close = mk(P, '}', cStart, P.L.b, []);
-        }
-        else {
-            close = mk(P, '}', P.L.b, P.L.b, []);
-        }
-        return mk(P, 'expansion', dStart, close.endIndex, [open, ...inner, close]);
-    }
-    // Simple expansion $VAR or $? $$ $@ etc
-    advance(P.L);
-    const dEnd = P.L.b;
-    const dollar = mk(P, '$', dStart, dEnd, []);
-    const nc = peek(P.L);
-    // $_ is special_variable_name only when not followed by more ident chars
-    if (nc === '_' && !isIdentChar(peek(P.L, 1))) {
-        const vStart = P.L.b;
-        advance(P.L);
-        const vn = mk(P, 'special_variable_name', vStart, P.L.b, []);
-        return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]);
-    }
-    if (isIdentStart(nc)) {
-        const vStart = P.L.b;
-        while (isIdentChar(peek(P.L)))
-            advance(P.L);
-        const vn = mk(P, 'variable_name', vStart, P.L.b, []);
-        return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]);
-    }
-    if (isDigit(nc)) {
-        const vStart = P.L.b;
-        advance(P.L);
-        const vn = mk(P, 'variable_name', vStart, P.L.b, []);
-        return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]);
-    }
-    if (SPECIAL_VARS.has(nc)) {
-        const vStart = P.L.b;
-        advance(P.L);
-        const vn = mk(P, 'special_variable_name', vStart, P.L.b, []);
-        return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]);
-    }
-    // Bare $ — just a $ leaf (tree-sitter treats trailing $ as literal)
-    return dollar;
-}
-function parseExpansionBody(P) {
-    const out = [];
-    skipBlanks(P.L);
-    // Bizarre cases: ${#!} ${!#} ${!##} ${!# } ${!## } all emit empty (expansion)
-    // — both # and ! become anonymous nodes when only combined with each other
-    // and optional trailing space before }. Note ${!##/} does NOT match (has
-    // content after), so it parses normally as (special_variable_name)(regex).
-    {
-        const c0 = peek(P.L);
-        const c1 = peek(P.L, 1);
-        if (c0 === '#' && c1 === '!' && peek(P.L, 2) === '}') {
-            advance(P.L);
-            advance(P.L);
-            return out;
-        }
-        if (c0 === '!' && c1 === '#') {
-            // ${!#} ${!##} with optional trailing space then }
-            let j = 2;
-            if (peek(P.L, j) === '#')
-                j++;
-            if (peek(P.L, j) === ' ')
-                j++;
-            if (peek(P.L, j) === '}') {
-                while (j-- > 0)
-                    advance(P.L);
-                return out;
-            }
-        }
-    }
-    // Optional # prefix for length
-    if (peek(P.L) === '#') {
-        const s = P.L.b;
-        advance(P.L);
-        out.push(mk(P, '#', s, P.L.b, []));
-    }
-    // Optional ! prefix for indirect expansion: ${!varname} ${!prefix*} ${!prefix@}
-    // Only when followed by an identifier — ${!} alone is special var $!
-    // Also = ~ prefixes (zsh-style ${=var} ${~var})
-    const pc = peek(P.L);
-    if ((pc === '!' || pc === '=' || pc === '~') &&
-        (isIdentStart(peek(P.L, 1)) || isDigit(peek(P.L, 1)))) {
-        const s = P.L.b;
-        advance(P.L);
-        out.push(mk(P, pc, s, P.L.b, []));
-    }
-    skipBlanks(P.L);
-    // Variable name
-    if (isIdentStart(peek(P.L))) {
-        const s = P.L.b;
-        while (isIdentChar(peek(P.L)))
-            advance(P.L);
-        out.push(mk(P, 'variable_name', s, P.L.b, []));
-    }
-    else if (isDigit(peek(P.L))) {
-        const s = P.L.b;
-        while (isDigit(peek(P.L)))
-            advance(P.L);
-        out.push(mk(P, 'variable_name', s, P.L.b, []));
-    }
-    else if (SPECIAL_VARS.has(peek(P.L))) {
-        const s = P.L.b;
-        advance(P.L);
-        out.push(mk(P, 'special_variable_name', s, P.L.b, []));
-    }
-    // Optional subscript [idx] — parsed arithmetically
-    if (peek(P.L) === '[') {
-        const varNode = out[out.length - 1];
-        const brOpen = P.L.b;
-        advance(P.L);
-        const brOpenNode = mk(P, '[', brOpen, P.L.b, []);
-        const idx = parseSubscriptIndexInline(P);
-        skipBlanks(P.L);
-        const brClose = P.L.b;
-        if (peek(P.L) === ']')
-            advance(P.L);
-        const brCloseNode = mk(P, ']', brClose, P.L.b, []);
-        if (varNode) {
-            const kids = idx
-                ? [varNode, brOpenNode, idx, brCloseNode]
-                : [varNode, brOpenNode, brCloseNode];
-            out[out.length - 1] = mk(P, 'subscript', varNode.startIndex, P.L.b, kids);
-        }
-    }
-    skipBlanks(P.L);
-    // Trailing * or @ for indirect expansion (${!prefix*} ${!prefix@}) or
-    // @operator for parameter transformation (${var@U} ${var@Q}) — anonymous
-    const tc = peek(P.L);
-    if ((tc === '*' || tc === '@') && peek(P.L, 1) === '}') {
-        const s = P.L.b;
-        advance(P.L);
-        out.push(mk(P, tc, s, P.L.b, []));
-        return out;
-    }
-    if (tc === '@' && isIdentStart(peek(P.L, 1))) {
-        // ${var@U} transformation — @ is anonymous, consume op char(s)
-        const s = P.L.b;
-        advance(P.L);
-        out.push(mk(P, '@', s, P.L.b, []));
-        while (isIdentChar(peek(P.L)))
-            advance(P.L);
-        return out;
-    }
-    // Operator :- := :? :+ - = ? + # ## % %% / // ^ ^^ , ,, etc.
-    const c = peek(P.L);
-    // Bare `:` substring operator ${var:off:len} — offset and length parsed
-    // arithmetically. Must come BEFORE the generic operator handling so `(` after
-    // `:` goes to parenthesized_expression not the array path. `:-` `:=` `:?`
-    // `:+` (no space) remain default-value operators; `: -1` (with space before
-    // -1) is substring with negative offset.
-    if (c === ':') {
-        const c1 = peek(P.L, 1);
-        // `:\n` or `:}` — empty substring expansion, emits nothing (variable_name only)
-        if (c1 === '\n' || c1 === '}') {
-            advance(P.L);
-            while (peek(P.L) === '\n')
-                advance(P.L);
-            return out;
-        }
-        if (c1 !== '-' && c1 !== '=' && c1 !== '?' && c1 !== '+') {
-            advance(P.L);
-            skipBlanks(P.L);
-            // Offset — arithmetic. `-N` at top level is a single number node per
-            // tree-sitter; inside parens it's unary_expression(number).
-            const offC = peek(P.L);
-            let off;
-            if (offC === '-' && isDigit(peek(P.L, 1))) {
-                const ns = P.L.b;
-                advance(P.L);
-                while (isDigit(peek(P.L)))
-                    advance(P.L);
-                off = mk(P, 'number', ns, P.L.b, []);
-            }
-            else {
-                off = parseArithExpr(P, ':}', 'var');
-            }
-            if (off)
-                out.push(off);
-            skipBlanks(P.L);
-            if (peek(P.L) === ':') {
-                advance(P.L);
-                skipBlanks(P.L);
-                const lenC = peek(P.L);
-                let len;
-                if (lenC === '-' && isDigit(peek(P.L, 1))) {
-                    const ns = P.L.b;
-                    advance(P.L);
-                    while (isDigit(peek(P.L)))
-                        advance(P.L);
-                    len = mk(P, 'number', ns, P.L.b, []);
-                }
-                else {
-                    len = parseArithExpr(P, '}', 'var');
-                }
-                if (len)
-                    out.push(len);
-            }
-            return out;
-        }
-    }
-    if (c === ':' ||
-        c === '#' ||
-        c === '%' ||
-        c === '/' ||
-        c === '^' ||
-        c === ',' ||
-        c === '-' ||
-        c === '=' ||
-        c === '?' ||
-        c === '+') {
-        const s = P.L.b;
-        const c1 = peek(P.L, 1);
-        let op = c;
-        if (c === ':' && (c1 === '-' || c1 === '=' || c1 === '?' || c1 === '+')) {
-            advance(P.L);
-            advance(P.L);
-            op = c + c1;
-        }
-        else if ((c === '#' || c === '%' || c === '/' || c === '^' || c === ',') &&
-            c1 === c) {
-            // Doubled operators: ## %% // ^^ ,,
-            advance(P.L);
-            advance(P.L);
-            op = c + c;
-        }
-        else {
-            advance(P.L);
-        }
-        out.push(mk(P, op, s, P.L.b, []));
-        // Rest is the default/replacement — parse as word or regex until }
-        // Pattern-matching operators (# ## % %% / // ^ ^^ , ,,) emit regex;
-        // value-substitution operators (:- := :? :+ - = ? + :) emit word.
-        // `/` and `//` split at next `/` into (regex)+(word) for pat/repl.
-        const isPattern = op === '#' ||
-            op === '##' ||
-            op === '%' ||
-            op === '%%' ||
-            op === '/' ||
-            op === '//' ||
-            op === '^' ||
-            op === '^^' ||
-            op === ',' ||
-            op === ',,';
-        if (op === '/' || op === '//') {
-            // Optional /# or /% anchor prefix — anonymous node
-            const ac = peek(P.L);
-            if (ac === '#' || ac === '%') {
-                const aStart = P.L.b;
-                advance(P.L);
-                out.push(mk(P, ac, aStart, P.L.b, []));
-            }
-            // Pattern: per grammar _expansion_regex_replacement, pattern is
-            // choice(regex, string, cmd_sub, seq(string, regex)). If it STARTS
-            // with ", emit (string) and any trailing chars become (regex).
-            // `${v//"${old}"/}` → (string(expansion)); `${v//"${c}"\//}` →
-            // (string)(regex).
-            if (peek(P.L) === '"') {
-                out.push(parseDoubleQuoted(P));
-                const tail = parseExpansionRest(P, 'regex', true);
-                if (tail)
-                    out.push(tail);
-            }
-            else {
-                const regex = parseExpansionRest(P, 'regex', true);
-                if (regex)
-                    out.push(regex);
-            }
-            if (peek(P.L) === '/') {
-                const sepStart = P.L.b;
-                advance(P.L);
-                out.push(mk(P, '/', sepStart, P.L.b, []));
-                // Replacement: per grammar, choice includes `seq(cmd_sub, word)`
-                // which emits TWO siblings (not concatenation). Also `(` at start
-                // of replacement is a regular word char, NOT array — unlike `:-`
-                // default-value context. `${v/(/(Gentoo ${x}, }` replacement
-                // `(Gentoo ${x}, ` is (concatenation (word)(expansion)(word)).
-                const repl = parseExpansionRest(P, 'replword', false);
-                if (repl) {
-                    // seq(cmd_sub, word) special case → siblings. Detected when
-                    // replacement is a concatenation of exactly 2 parts with first
-                    // being command_substitution.
-                    if (repl.type === 'concatenation' &&
-                        repl.children.length === 2 &&
-                        repl.children[0].type === 'command_substitution') {
-                        out.push(repl.children[0]);
-                        out.push(repl.children[1]);
-                    }
-                    else {
-                        out.push(repl);
-                    }
-                }
-            }
-        }
-        else if (op === '#' || op === '##' || op === '%' || op === '%%') {
-            // Pattern-removal: per grammar _expansion_regex, pattern is
-            // repeat(choice(regex, string, raw_string, ')')). Each quote/string
-            // is a SIBLING, not absorbed into one regex. `${f%'str'*}` →
-            // (raw_string)(regex); `${f/'str'*}` (slash) stays single regex.
-            for (const p of parseExpansionRegexSegmented(P))
-                out.push(p);
-        }
-        else {
-            const rest = parseExpansionRest(P, isPattern ? 'regex' : 'word', false);
-            if (rest)
-                out.push(rest);
-        }
-    }
-    return out;
-}
-function parseExpansionRest(P, nodeType, stopAtSlash) {
-    // Don't skipBlanks — `${var:- }` space IS the word. Stop at } or newline
-    // (`${var:\n}` emits no word). stopAtSlash=true stops at `/` for pat/repl
-    // split in ${var/pat/repl}. nodeType 'replword' is word-mode for the
-    // replacement in `/` `//` — same as 'word' but `(` is NOT array.
-    const start = P.L.b;
-    // Value-substitution RHS starting with `(` parses as array: ${var:-(x)} →
-    // (expansion (variable_name) (array (word))). Only for 'word' context (not
-    // pattern-matching operators which emit regex, and not 'replword' where `(`
-    // is a regular char per grammar `_expansion_regex_replacement`).
-    if (nodeType === 'word' && peek(P.L) === '(') {
-        advance(P.L);
-        const open = mk(P, '(', start, P.L.b, []);
-        const elems = [open];
-        while (P.L.i < P.L.len) {
-            skipBlanks(P.L);
-            const c = peek(P.L);
-            if (c === ')' || c === '}' || c === '\n' || c === '')
-                break;
-            const wStart = P.L.b;
-            while (P.L.i < P.L.len) {
-                const wc = peek(P.L);
-                if (wc === ')' ||
-                    wc === '}' ||
-                    wc === ' ' ||
-                    wc === '\t' ||
-                    wc === '\n' ||
-                    wc === '') {
-                    break;
-                }
-                advance(P.L);
-            }
-            if (P.L.b > wStart)
-                elems.push(mk(P, 'word', wStart, P.L.b, []));
-            else
-                break;
-        }
-        if (peek(P.L) === ')') {
-            const cStart = P.L.b;
-            advance(P.L);
-            elems.push(mk(P, ')', cStart, P.L.b, []));
-        }
-        while (peek(P.L) === '\n')
-            advance(P.L);
-        return mk(P, 'array', start, P.L.b, elems);
-    }
-    // REGEX mode: flat single-span scan. Quotes are opaque (skipped past so
-    // `/` inside them doesn't break stopAtSlash), but NOT emitted as separate
-    // nodes — the entire range becomes one regex node.
-    if (nodeType === 'regex') {
-        let braceDepth = 0;
-        while (P.L.i < P.L.len) {
-            const c = peek(P.L);
-            if (c === '\n')
-                break;
-            if (braceDepth === 0) {
-                if (c === '}')
-                    break;
-                if (stopAtSlash && c === '/')
-                    break;
-            }
-            if (c === '\\' && P.L.i + 1 < P.L.len) {
-                advance(P.L);
-                advance(P.L);
-                continue;
-            }
-            if (c === '"' || c === "'") {
-                advance(P.L);
-                while (P.L.i < P.L.len && peek(P.L) !== c) {
-                    if (peek(P.L) === '\\' && P.L.i + 1 < P.L.len)
-                        advance(P.L);
-                    advance(P.L);
-                }
-                if (peek(P.L) === c)
-                    advance(P.L);
-                continue;
-            }
-            // Skip past nested ${...} $(...) $[...] so their } / don't terminate us
-            if (c === '$') {
-                const c1 = peek(P.L, 1);
-                if (c1 === '{') {
-                    let d = 0;
-                    advance(P.L);
-                    advance(P.L);
-                    d++;
-                    while (P.L.i < P.L.len && d > 0) {
-                        const nc = peek(P.L);
-                        if (nc === '{')
-                            d++;
-                        else if (nc === '}')
-                            d--;
-                        advance(P.L);
-                    }
-                    continue;
-                }
-                if (c1 === '(') {
-                    let d = 0;
-                    advance(P.L);
-                    advance(P.L);
-                    d++;
-                    while (P.L.i < P.L.len && d > 0) {
-                        const nc = peek(P.L);
-                        if (nc === '(')
-                            d++;
-                        else if (nc === ')')
-                            d--;
-                        advance(P.L);
-                    }
-                    continue;
-                }
-            }
-            if (c === '{')
-                braceDepth++;
-            else if (c === '}' && braceDepth > 0)
-                braceDepth--;
-            advance(P.L);
-        }
-        const end = P.L.b;
-        while (peek(P.L) === '\n')
-            advance(P.L);
-        if (end === start)
-            return null;
-        return mk(P, 'regex', start, end, []);
-    }
-    // WORD mode: segmenting parser — recognize nested ${...}, $(...), $'...',
-    // "...", '...', $ident, <(...)/>(...); bare chars accumulate into word
-    // segments. Multiple parts → wrapped in concatenation.
-    const parts = [];
-    let segStart = P.L.b;
-    let braceDepth = 0;
-    const flushSeg = () => {
-        if (P.L.b > segStart) {
-            parts.push(mk(P, 'word', segStart, P.L.b, []));
-        }
-    };
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '\n')
-            break;
-        if (braceDepth === 0) {
-            if (c === '}')
-                break;
-            if (stopAtSlash && c === '/')
-                break;
-        }
-        if (c === '\\' && P.L.i + 1 < P.L.len) {
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        const c1 = peek(P.L, 1);
-        if (c === '$') {
-            if (c1 === '{' || c1 === '(' || c1 === '[') {
-                flushSeg();
-                const exp = parseDollarLike(P);
-                if (exp)
-                    parts.push(exp);
-                segStart = P.L.b;
-                continue;
-            }
-            if (c1 === "'") {
-                // $'...' ANSI-C string
-                flushSeg();
-                const aStart = P.L.b;
-                advance(P.L);
-                advance(P.L);
-                while (P.L.i < P.L.len && peek(P.L) !== "'") {
-                    if (peek(P.L) === '\\' && P.L.i + 1 < P.L.len)
-                        advance(P.L);
-                    advance(P.L);
-                }
-                if (peek(P.L) === "'")
-                    advance(P.L);
-                parts.push(mk(P, 'ansi_c_string', aStart, P.L.b, []));
-                segStart = P.L.b;
-                continue;
-            }
-            if (isIdentStart(c1) || isDigit(c1) || SPECIAL_VARS.has(c1)) {
-                flushSeg();
-                const exp = parseDollarLike(P);
-                if (exp)
-                    parts.push(exp);
-                segStart = P.L.b;
-                continue;
-            }
-        }
-        if (c === '"') {
-            flushSeg();
-            parts.push(parseDoubleQuoted(P));
-            segStart = P.L.b;
-            continue;
-        }
-        if (c === "'") {
-            flushSeg();
-            const rStart = P.L.b;
-            advance(P.L);
-            while (P.L.i < P.L.len && peek(P.L) !== "'")
-                advance(P.L);
-            if (peek(P.L) === "'")
-                advance(P.L);
-            parts.push(mk(P, 'raw_string', rStart, P.L.b, []));
-            segStart = P.L.b;
-            continue;
-        }
-        if ((c === '<' || c === '>') && c1 === '(') {
-            flushSeg();
-            const ps = parseProcessSub(P);
-            if (ps)
-                parts.push(ps);
-            segStart = P.L.b;
-            continue;
-        }
-        if (c === '`') {
-            flushSeg();
-            const bt = parseBacktick(P);
-            if (bt)
-                parts.push(bt);
-            segStart = P.L.b;
-            continue;
-        }
-        // Brace tracking so nested {a,b} brace-expansion chars don't prematurely
-        // terminate (rare, but the `?` in `${cond}? (` should be treated as word).
-        if (c === '{')
-            braceDepth++;
-        else if (c === '}' && braceDepth > 0)
-            braceDepth--;
-        advance(P.L);
-    }
-    flushSeg();
-    // Consume trailing newlines before } so caller sees }
-    while (peek(P.L) === '\n')
-        advance(P.L);
-    // Tree-sitter skips leading whitespace (extras) in expansion RHS when
-    // there's content after: `${2+ ${2}}` → just (expansion). But `${v:- }`
-    // (space-only RHS) keeps the space as (word). So drop leading whitespace-
-    // only word segment if it's NOT the only part.
-    if (parts.length > 1 &&
-        parts[0].type === 'word' &&
-        /^[ \t]+$/.test(parts[0].text)) {
-        parts.shift();
-    }
-    if (parts.length === 0)
-        return null;
-    if (parts.length === 1)
-        return parts[0];
-    // Multiple parts: wrap in concatenation (word mode keeps concat wrapping;
-    // regex mode also concats per tree-sitter for mixed quote+glob patterns).
-    const last = parts[parts.length - 1];
-    return mk(P, 'concatenation', parts[0].startIndex, last.endIndex, parts);
-}
-// Pattern for # ## % %% operators — per grammar _expansion_regex:
-// repeat(choice(regex, string, raw_string, ')', /\s+/→regex)). Each quote
-// becomes a SIBLING node, not absorbed. `${f%'str'*}` → (raw_string)(regex).
-function parseExpansionRegexSegmented(P) {
-    const out = [];
-    let segStart = P.L.b;
-    const flushRegex = () => {
-        if (P.L.b > segStart)
-            out.push(mk(P, 'regex', segStart, P.L.b, []));
-    };
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '}' || c === '\n')
-            break;
-        if (c === '\\' && P.L.i + 1 < P.L.len) {
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        if (c === '"') {
-            flushRegex();
-            out.push(parseDoubleQuoted(P));
-            segStart = P.L.b;
-            continue;
-        }
-        if (c === "'") {
-            flushRegex();
-            const rStart = P.L.b;
-            advance(P.L);
-            while (P.L.i < P.L.len && peek(P.L) !== "'")
-                advance(P.L);
-            if (peek(P.L) === "'")
-                advance(P.L);
-            out.push(mk(P, 'raw_string', rStart, P.L.b, []));
-            segStart = P.L.b;
-            continue;
-        }
-        // Nested ${...} $(...) — opaque scan so their } doesn't terminate us
-        if (c === '$') {
-            const c1 = peek(P.L, 1);
-            if (c1 === '{') {
-                let d = 1;
-                advance(P.L);
-                advance(P.L);
-                while (P.L.i < P.L.len && d > 0) {
-                    const nc = peek(P.L);
-                    if (nc === '{')
-                        d++;
-                    else if (nc === '}')
-                        d--;
-                    advance(P.L);
-                }
-                continue;
-            }
-            if (c1 === '(') {
-                let d = 1;
-                advance(P.L);
-                advance(P.L);
-                while (P.L.i < P.L.len && d > 0) {
-                    const nc = peek(P.L);
-                    if (nc === '(')
-                        d++;
-                    else if (nc === ')')
-                        d--;
-                    advance(P.L);
-                }
-                continue;
-            }
-        }
-        advance(P.L);
-    }
-    flushRegex();
-    while (peek(P.L) === '\n')
-        advance(P.L);
-    return out;
-}
-function parseBacktick(P) {
-    const start = P.L.b;
-    advance(P.L);
-    const open = mk(P, '`', start, P.L.b, []);
-    P.inBacktick++;
-    // Parse statements inline — stop at closing backtick
-    const body = [];
-    while (true) {
-        skipBlanks(P.L);
-        if (peek(P.L) === '`' || peek(P.L) === '')
-            break;
-        const save = saveLex(P.L);
-        const t = nextToken(P.L, 'cmd');
-        if (t.type === 'EOF' || t.type === 'BACKTICK') {
-            restoreLex(P.L, save);
-            break;
-        }
-        if (t.type === 'NEWLINE')
-            continue;
-        restoreLex(P.L, save);
-        const stmt = parseAndOr(P);
-        if (!stmt)
-            break;
-        body.push(stmt);
-        skipBlanks(P.L);
-        if (peek(P.L) === '`')
-            break;
-        const save2 = saveLex(P.L);
-        const sep = nextToken(P.L, 'cmd');
-        if (sep.type === 'OP' && (sep.value === ';' || sep.value === '&')) {
-            body.push(leaf(P, sep.value, sep));
-        }
-        else if (sep.type !== 'NEWLINE') {
-            restoreLex(P.L, save2);
-        }
-    }
-    P.inBacktick--;
-    let close;
-    if (peek(P.L) === '`') {
-        const cStart = P.L.b;
-        advance(P.L);
-        close = mk(P, '`', cStart, P.L.b, []);
-    }
-    else {
-        close = mk(P, '`', P.L.b, P.L.b, []);
-    }
-    // Empty backticks (whitespace/newline only) are elided entirely by
-    // tree-sitter — used as a line-continuation hack: "foo"`<newline>`"bar"
-    // → (concatenation (string) (string)) with no command_substitution.
-    if (body.length === 0)
-        return null;
-    return mk(P, 'command_substitution', start, close.endIndex, [
-        open,
-        ...body,
-        close,
-    ]);
-}
-function parseIf(P, ifTok) {
-    const ifKw = leaf(P, 'if', ifTok);
-    const kids = [ifKw];
-    const cond = parseStatements(P, null);
-    kids.push(...cond);
-    consumeKeyword(P, 'then', kids);
-    const body = parseStatements(P, null);
-    kids.push(...body);
-    while (true) {
-        const save = saveLex(P.L);
-        const t = nextToken(P.L, 'cmd');
-        if (t.type === 'WORD' && t.value === 'elif') {
-            const eKw = leaf(P, 'elif', t);
-            const eCond = parseStatements(P, null);
-            const eKids = [eKw, ...eCond];
-            consumeKeyword(P, 'then', eKids);
-            const eBody = parseStatements(P, null);
-            eKids.push(...eBody);
-            const last = eKids[eKids.length - 1];
-            kids.push(mk(P, 'elif_clause', eKw.startIndex, last.endIndex, eKids));
-        }
-        else if (t.type === 'WORD' && t.value === 'else') {
-            const elKw = leaf(P, 'else', t);
-            const elBody = parseStatements(P, null);
-            const last = elBody.length > 0 ? elBody[elBody.length - 1] : elKw;
-            kids.push(mk(P, 'else_clause', elKw.startIndex, last.endIndex, [elKw, ...elBody]));
-        }
-        else {
-            restoreLex(P.L, save);
-            break;
-        }
-    }
-    consumeKeyword(P, 'fi', kids);
-    const last = kids[kids.length - 1];
-    return mk(P, 'if_statement', ifKw.startIndex, last.endIndex, kids);
-}
-function parseWhile(P, kwTok) {
-    const kw = leaf(P, kwTok.value, kwTok);
-    const kids = [kw];
-    const cond = parseStatements(P, null);
-    kids.push(...cond);
-    const dg = parseDoGroup(P);
-    if (dg)
-        kids.push(dg);
-    const last = kids[kids.length - 1];
-    return mk(P, 'while_statement', kw.startIndex, last.endIndex, kids);
-}
-function parseFor(P, forTok) {
-    const forKw = leaf(P, forTok.value, forTok);
-    skipBlanks(P.L);
-    // C-style for (( ; ; )) — only for `for`, not `select`
-    if (forTok.value === 'for' && peek(P.L) === '(' && peek(P.L, 1) === '(') {
-        const oStart = P.L.b;
-        advance(P.L);
-        advance(P.L);
-        const open = mk(P, '((', oStart, P.L.b, []);
-        const kids = [forKw, open];
-        // init; cond; update — all three use 'assign' mode so `c = expr` emits
-        // variable_assignment, while bare idents (c in `c<=5`) → word. Each
-        // clause may be a comma-separated list.
-        for (let k = 0; k < 3; k++) {
-            skipBlanks(P.L);
-            const es = parseArithCommaList(P, k < 2 ? ';' : '))', 'assign');
-            kids.push(...es);
-            if (k < 2) {
-                if (peek(P.L) === ';') {
-                    const s = P.L.b;
-                    advance(P.L);
-                    kids.push(mk(P, ';', s, P.L.b, []));
-                }
-            }
-        }
-        skipBlanks(P.L);
-        if (peek(P.L) === ')' && peek(P.L, 1) === ')') {
-            const cStart = P.L.b;
-            advance(P.L);
-            advance(P.L);
-            kids.push(mk(P, '))', cStart, P.L.b, []));
-        }
-        // Optional ; or newline
-        const save = saveLex(P.L);
-        const sep = nextToken(P.L, 'cmd');
-        if (sep.type === 'OP' && sep.value === ';') {
-            kids.push(leaf(P, ';', sep));
-        }
-        else if (sep.type !== 'NEWLINE') {
-            restoreLex(P.L, save);
-        }
-        const dg = parseDoGroup(P);
-        if (dg) {
-            kids.push(dg);
-        }
-        else {
-            // C-style for can also use `{ ... }` body instead of `do ... done`
-            skipNewlines(P);
-            skipBlanks(P.L);
-            if (peek(P.L) === '{') {
-                const bOpen = P.L.b;
-                advance(P.L);
-                const brace = mk(P, '{', bOpen, P.L.b, []);
-                const body = parseStatements(P, '}');
-                let bClose;
-                if (peek(P.L) === '}') {
-                    const cs = P.L.b;
-                    advance(P.L);
-                    bClose = mk(P, '}', cs, P.L.b, []);
-                }
-                else {
-                    bClose = mk(P, '}', P.L.b, P.L.b, []);
-                }
-                kids.push(mk(P, 'compound_statement', brace.startIndex, bClose.endIndex, [
-                    brace,
-                    ...body,
-                    bClose,
-                ]));
-            }
-        }
-        const last = kids[kids.length - 1];
-        return mk(P, 'c_style_for_statement', forKw.startIndex, last.endIndex, kids);
-    }
-    // Regular for VAR in words; do ... done
-    const kids = [forKw];
-    const varTok = nextToken(P.L, 'arg');
-    kids.push(mk(P, 'variable_name', varTok.start, varTok.end, []));
-    skipBlanks(P.L);
-    const save = saveLex(P.L);
-    const inTok = nextToken(P.L, 'arg');
-    if (inTok.type === 'WORD' && inTok.value === 'in') {
-        kids.push(leaf(P, 'in', inTok));
-        while (true) {
-            skipBlanks(P.L);
-            const c = peek(P.L);
-            if (c === ';' || c === '\n' || c === '')
-                break;
-            const w = parseWord(P, 'arg');
-            if (!w)
-                break;
-            kids.push(w);
-        }
-    }
-    else {
-        restoreLex(P.L, save);
-    }
-    // Separator
-    const save2 = saveLex(P.L);
-    const sep = nextToken(P.L, 'cmd');
-    if (sep.type === 'OP' && sep.value === ';') {
-        kids.push(leaf(P, ';', sep));
-    }
-    else if (sep.type !== 'NEWLINE') {
-        restoreLex(P.L, save2);
-    }
-    const dg = parseDoGroup(P);
-    if (dg)
-        kids.push(dg);
-    const last = kids[kids.length - 1];
-    return mk(P, 'for_statement', forKw.startIndex, last.endIndex, kids);
-}
-function parseDoGroup(P) {
-    skipNewlines(P);
-    const save = saveLex(P.L);
-    const doTok = nextToken(P.L, 'cmd');
-    if (doTok.type !== 'WORD' || doTok.value !== 'do') {
-        restoreLex(P.L, save);
-        return null;
-    }
-    const doKw = leaf(P, 'do', doTok);
-    const body = parseStatements(P, null);
-    const kids = [doKw, ...body];
-    consumeKeyword(P, 'done', kids);
-    const last = kids[kids.length - 1];
-    return mk(P, 'do_group', doKw.startIndex, last.endIndex, kids);
-}
-function parseCase(P, caseTok) {
-    const caseKw = leaf(P, 'case', caseTok);
-    const kids = [caseKw];
-    skipBlanks(P.L);
-    const word = parseWord(P, 'arg');
-    if (word)
-        kids.push(word);
-    skipBlanks(P.L);
-    consumeKeyword(P, 'in', kids);
-    skipNewlines(P);
-    while (true) {
-        skipBlanks(P.L);
-        skipNewlines(P);
-        const save = saveLex(P.L);
-        const t = nextToken(P.L, 'arg');
-        if (t.type === 'WORD' && t.value === 'esac') {
-            kids.push(leaf(P, 'esac', t));
-            break;
-        }
-        if (t.type === 'EOF')
-            break;
-        restoreLex(P.L, save);
-        const item = parseCaseItem(P);
-        if (!item)
-            break;
-        kids.push(item);
-    }
-    const last = kids[kids.length - 1];
-    return mk(P, 'case_statement', caseKw.startIndex, last.endIndex, kids);
-}
-function parseCaseItem(P) {
-    skipBlanks(P.L);
-    const start = P.L.b;
-    const kids = [];
-    // Optional leading '(' before pattern — bash allows (pattern) syntax
-    if (peek(P.L) === '(') {
-        const s = P.L.b;
-        advance(P.L);
-        kids.push(mk(P, '(', s, P.L.b, []));
-    }
-    // Pattern(s)
-    let isFirstAlt = true;
-    while (true) {
-        skipBlanks(P.L);
-        const c = peek(P.L);
-        if (c === ')' || c === '')
-            break;
-        const pats = parseCasePattern(P);
-        if (pats.length === 0)
-            break;
-        // tree-sitter quirk: first alternative with quotes is inlined as flat
-        // siblings; subsequent alternatives are wrapped in (concatenation) with
-        // `word` instead of `extglob_pattern` for bare segments.
-        if (!isFirstAlt && pats.length > 1) {
-            const rewritten = pats.map(p => p.type === 'extglob_pattern'
-                ? mk(P, 'word', p.startIndex, p.endIndex, [])
-                : p);
-            const first = rewritten[0];
-            const last = rewritten[rewritten.length - 1];
-            kids.push(mk(P, 'concatenation', first.startIndex, last.endIndex, rewritten));
-        }
-        else {
-            kids.push(...pats);
-        }
-        isFirstAlt = false;
-        skipBlanks(P.L);
-        // \<newline> line continuation between alternatives
-        if (peek(P.L) === '\\' && peek(P.L, 1) === '\n') {
-            advance(P.L);
-            advance(P.L);
-            skipBlanks(P.L);
-        }
-        if (peek(P.L) === '|') {
-            const s = P.L.b;
-            advance(P.L);
-            kids.push(mk(P, '|', s, P.L.b, []));
-            // \<newline> after | is also a line continuation
-            if (peek(P.L) === '\\' && peek(P.L, 1) === '\n') {
-                advance(P.L);
-                advance(P.L);
-            }
-        }
-        else {
-            break;
-        }
-    }
-    if (peek(P.L) === ')') {
-        const s = P.L.b;
-        advance(P.L);
-        kids.push(mk(P, ')', s, P.L.b, []));
-    }
-    const body = parseStatements(P, null);
-    kids.push(...body);
-    const save = saveLex(P.L);
-    const term = nextToken(P.L, 'cmd');
-    if (term.type === 'OP' &&
-        (term.value === ';;' || term.value === ';&' || term.value === ';;&')) {
-        kids.push(leaf(P, term.value, term));
-    }
-    else {
-        restoreLex(P.L, save);
-    }
-    if (kids.length === 0)
-        return null;
-    // tree-sitter quirk: case_item with EMPTY body and a single pattern matching
-    // extglob-operator-char-prefix (no actual glob metachars) downgrades to word.
-    // `-o) owner=$2 ;;` (has body) → extglob_pattern; `-g) ;;` (empty) → word.
-    if (body.length === 0) {
-        for (let i = 0; i < kids.length; i++) {
-            const k = kids[i];
-            if (k.type !== 'extglob_pattern')
-                continue;
-            const text = sliceBytes(P, k.startIndex, k.endIndex);
-            if (/^[-+?*@!][a-zA-Z]/.test(text) && !/[*?(]/.test(text)) {
-                kids[i] = mk(P, 'word', k.startIndex, k.endIndex, []);
-            }
-        }
-    }
-    const last = kids[kids.length - 1];
-    return mk(P, 'case_item', start, last.endIndex, kids);
-}
-function parseCasePattern(P) {
-    skipBlanks(P.L);
-    const save = saveLex(P.L);
-    const start = P.L.b;
-    const startI = P.L.i;
-    let parenDepth = 0;
-    let hasDollar = false;
-    let hasBracketOutsideParen = false;
-    let hasQuote = false;
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '\\' && P.L.i + 1 < P.L.len) {
-            // Escaped char — consume both (handles `bar\ baz` as single pattern)
-            // \<newline> is a line continuation; eat it but stay in pattern.
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        if (c === '"' || c === "'") {
-            hasQuote = true;
-            // Skip past the quoted segment so its content (spaces, |, etc.) doesn't
-            // break the peek-ahead scan.
-            advance(P.L);
-            while (P.L.i < P.L.len && peek(P.L) !== c) {
-                if (peek(P.L) === '\\' && P.L.i + 1 < P.L.len)
-                    advance(P.L);
-                advance(P.L);
-            }
-            if (peek(P.L) === c)
-                advance(P.L);
-            continue;
-        }
-        // Paren counting: any ( inside pattern opens a scope; don't break at ) or |
-        // until balanced. Handles extglob *(a|b) and nested shapes *([0-9])([0-9]).
-        if (c === '(') {
-            parenDepth++;
-            advance(P.L);
-            continue;
-        }
-        if (parenDepth > 0) {
-            if (c === ')') {
-                parenDepth--;
-                advance(P.L);
-                continue;
-            }
-            if (c === '\n')
-                break;
-            advance(P.L);
-            continue;
-        }
-        if (c === ')' || c === '|' || c === ' ' || c === '\t' || c === '\n')
-            break;
-        if (c === '$')
-            hasDollar = true;
-        if (c === '[')
-            hasBracketOutsideParen = true;
-        advance(P.L);
-    }
-    if (P.L.b === start)
-        return [];
-    const text = P.src.slice(startI, P.L.i);
-    const hasExtglobParen = /[*?+@!]\(/.test(text);
-    // Quoted segments in pattern: tree-sitter splits at quote boundaries into
-    // multiple sibling nodes. `*"foo"*` → (extglob_pattern)(string)(extglob_pattern).
-    // Re-scan with a segmenting pass.
-    if (hasQuote && !hasExtglobParen) {
-        restoreLex(P.L, save);
-        return parseCasePatternSegmented(P);
-    }
-    // tree-sitter splits patterns with [ or $ into concatenation via word parsing
-    // UNLESS pattern has extglob parens (those override and emit extglob_pattern).
-    // `*.[1357]` → concat(word word number word); `${PN}.pot` → concat(expansion word);
-    // but `*([0-9])` → extglob_pattern (has extglob paren).
-    if (!hasExtglobParen && (hasDollar || hasBracketOutsideParen)) {
-        restoreLex(P.L, save);
-        const w = parseWord(P, 'arg');
-        return w ? [w] : [];
-    }
-    // Patterns starting with extglob operator chars (+ - ? * @ !) followed by
-    // identifier chars are extglob_pattern per tree-sitter, even without parens
-    // or glob metachars. `-o)` → extglob_pattern; plain `foo)` → word.
-    const type = hasExtglobParen || /[*?]/.test(text) || /^[-+?*@!][a-zA-Z]/.test(text)
-        ? 'extglob_pattern'
-        : 'word';
-    return [mk(P, type, start, P.L.b, [])];
-}
-// Segmented scan for case patterns containing quotes: `*"foo"*` →
-// [extglob_pattern, string, extglob_pattern]. Bare segments → extglob_pattern
-// if they have */?, else word. Stops at ) | space tab newline outside quotes.
-function parseCasePatternSegmented(P) {
-    const parts = [];
-    let segStart = P.L.b;
-    let segStartI = P.L.i;
-    const flushSeg = () => {
-        if (P.L.i > segStartI) {
-            const t = P.src.slice(segStartI, P.L.i);
-            const type = /[*?]/.test(t) ? 'extglob_pattern' : 'word';
-            parts.push(mk(P, type, segStart, P.L.b, []));
-        }
-    };
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '\\' && P.L.i + 1 < P.L.len) {
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        if (c === '"') {
-            flushSeg();
-            parts.push(parseDoubleQuoted(P));
-            segStart = P.L.b;
-            segStartI = P.L.i;
-            continue;
-        }
-        if (c === "'") {
-            flushSeg();
-            const tok = nextToken(P.L, 'arg');
-            parts.push(leaf(P, 'raw_string', tok));
-            segStart = P.L.b;
-            segStartI = P.L.i;
-            continue;
-        }
-        if (c === ')' || c === '|' || c === ' ' || c === '\t' || c === '\n')
-            break;
-        advance(P.L);
-    }
-    flushSeg();
-    return parts;
-}
-function parseFunction(P, fnTok) {
-    const fnKw = leaf(P, 'function', fnTok);
-    skipBlanks(P.L);
-    const nameTok = nextToken(P.L, 'arg');
-    const name = mk(P, 'word', nameTok.start, nameTok.end, []);
-    const kids = [fnKw, name];
-    skipBlanks(P.L);
-    if (peek(P.L) === '(' && peek(P.L, 1) === ')') {
-        const o = nextToken(P.L, 'cmd');
-        const c = nextToken(P.L, 'cmd');
-        kids.push(leaf(P, '(', o));
-        kids.push(leaf(P, ')', c));
-    }
-    skipBlanks(P.L);
-    skipNewlines(P);
-    const body = parseCommand(P);
-    if (body) {
-        // Hoist redirects from redirected_statement(compound_statement, ...) to
-        // function_definition level per tree-sitter grammar
-        if (body.type === 'redirected_statement' &&
-            body.children.length >= 2 &&
-            body.children[0].type === 'compound_statement') {
-            kids.push(...body.children);
-        }
-        else {
-            kids.push(body);
-        }
-    }
-    const last = kids[kids.length - 1];
-    return mk(P, 'function_definition', fnKw.startIndex, last.endIndex, kids);
-}
-function parseDeclaration(P, kwTok) {
-    const kw = leaf(P, kwTok.value, kwTok);
-    const kids = [kw];
-    while (true) {
-        skipBlanks(P.L);
-        const c = peek(P.L);
-        if (c === '' ||
-            c === '\n' ||
-            c === ';' ||
-            c === '&' ||
-            c === '|' ||
-            c === ')' ||
-            c === '<' ||
-            c === '>') {
-            break;
-        }
-        const a = tryParseAssignment(P);
-        if (a) {
-            kids.push(a);
-            continue;
-        }
-        // Quoted string or concatenation: `export "FOO=bar"`, `export 'X'`
-        if (c === '"' || c === "'" || c === '$') {
-            const w = parseWord(P, 'arg');
-            if (w) {
-                kids.push(w);
-                continue;
-            }
-            break;
-        }
-        // Flag like -a or bare variable name
-        const save = saveLex(P.L);
-        const tok = nextToken(P.L, 'arg');
-        if (tok.type === 'WORD' || tok.type === 'NUMBER') {
-            if (tok.value.startsWith('-')) {
-                kids.push(leaf(P, 'word', tok));
-            }
-            else if (isIdentStart(tok.value[0] ?? '')) {
-                kids.push(mk(P, 'variable_name', tok.start, tok.end, []));
-            }
-            else {
-                kids.push(leaf(P, 'word', tok));
-            }
-        }
-        else {
-            restoreLex(P.L, save);
-            break;
-        }
-    }
-    const last = kids[kids.length - 1];
-    return mk(P, 'declaration_command', kw.startIndex, last.endIndex, kids);
-}
-function parseUnset(P, kwTok) {
-    const kw = leaf(P, 'unset', kwTok);
-    const kids = [kw];
-    while (true) {
-        skipBlanks(P.L);
-        const c = peek(P.L);
-        if (c === '' ||
-            c === '\n' ||
-            c === ';' ||
-            c === '&' ||
-            c === '|' ||
-            c === ')' ||
-            c === '<' ||
-            c === '>') {
-            break;
-        }
-        // SECURITY: use parseWord (not raw nextToken) so quoted strings like
-        // `unset 'a[$(id)]'` emit a raw_string child that ast.ts can reject.
-        // Previously `break` silently dropped non-WORD args — hiding the
-        // arithmetic-subscript code-exec vector from the security walker.
-        const arg = parseWord(P, 'arg');
-        if (!arg)
-            break;
-        if (arg.type === 'word') {
-            if (arg.text.startsWith('-')) {
-                kids.push(arg);
-            }
-            else {
-                kids.push(mk(P, 'variable_name', arg.startIndex, arg.endIndex, []));
-            }
-        }
-        else {
-            kids.push(arg);
-        }
-    }
-    const last = kids[kids.length - 1];
-    return mk(P, 'unset_command', kw.startIndex, last.endIndex, kids);
-}
-function consumeKeyword(P, name, kids) {
-    skipNewlines(P);
-    const save = saveLex(P.L);
-    const t = nextToken(P.L, 'cmd');
-    if (t.type === 'WORD' && t.value === name) {
-        kids.push(leaf(P, name, t));
-    }
-    else {
-        restoreLex(P.L, save);
-    }
-}
-// ───────────────────── Test & Arithmetic Expressions ─────────────────────
-function parseTestExpr(P, closer) {
-    return parseTestOr(P, closer);
-}
-function parseTestOr(P, closer) {
-    let left = parseTestAnd(P, closer);
-    if (!left)
-        return null;
-    while (true) {
-        skipBlanks(P.L);
-        const save = saveLex(P.L);
-        if (peek(P.L) === '|' && peek(P.L, 1) === '|') {
-            const s = P.L.b;
-            advance(P.L);
-            advance(P.L);
-            const op = mk(P, '||', s, P.L.b, []);
-            const right = parseTestAnd(P, closer);
-            if (!right) {
-                restoreLex(P.L, save);
-                break;
-            }
-            left = mk(P, 'binary_expression', left.startIndex, right.endIndex, [
-                left,
-                op,
-                right,
-            ]);
-        }
-        else {
-            break;
-        }
-    }
-    return left;
-}
-function parseTestAnd(P, closer) {
-    let left = parseTestUnary(P, closer);
-    if (!left)
-        return null;
-    while (true) {
-        skipBlanks(P.L);
-        if (peek(P.L) === '&' && peek(P.L, 1) === '&') {
-            const s = P.L.b;
-            advance(P.L);
-            advance(P.L);
-            const op = mk(P, '&&', s, P.L.b, []);
-            const right = parseTestUnary(P, closer);
-            if (!right)
-                break;
-            left = mk(P, 'binary_expression', left.startIndex, right.endIndex, [
-                left,
-                op,
-                right,
-            ]);
-        }
-        else {
-            break;
-        }
-    }
-    return left;
-}
-function parseTestUnary(P, closer) {
-    skipBlanks(P.L);
-    const c = peek(P.L);
-    if (c === '(') {
-        const s = P.L.b;
-        advance(P.L);
-        const open = mk(P, '(', s, P.L.b, []);
-        const inner = parseTestOr(P, closer);
-        skipBlanks(P.L);
-        let close;
-        if (peek(P.L) === ')') {
-            const cs = P.L.b;
-            advance(P.L);
-            close = mk(P, ')', cs, P.L.b, []);
-        }
-        else {
-            close = mk(P, ')', P.L.b, P.L.b, []);
-        }
-        const kids = inner ? [open, inner, close] : [open, close];
-        return mk(P, 'parenthesized_expression', open.startIndex, close.endIndex, kids);
-    }
-    return parseTestBinary(P, closer);
-}
-/**
- * Parse `!`-negated or test-operator (`-f`) or parenthesized primary — but NOT
- * a binary comparison. Used as LHS of binary_expression so `! x =~ y` binds
- * `!` to `x` only, not the whole `x =~ y`.
- */
-function parseTestNegatablePrimary(P, closer) {
-    skipBlanks(P.L);
-    const c = peek(P.L);
-    if (c === '!') {
-        const s = P.L.b;
-        advance(P.L);
-        const bang = mk(P, '!', s, P.L.b, []);
-        const inner = parseTestNegatablePrimary(P, closer);
-        if (!inner)
-            return bang;
-        return mk(P, 'unary_expression', bang.startIndex, inner.endIndex, [
-            bang,
-            inner,
-        ]);
-    }
-    if (c === '-' && isIdentStart(peek(P.L, 1))) {
-        const s = P.L.b;
-        advance(P.L);
-        while (isIdentChar(peek(P.L)))
-            advance(P.L);
-        const op = mk(P, 'test_operator', s, P.L.b, []);
-        skipBlanks(P.L);
-        const arg = parseTestPrimary(P, closer);
-        if (!arg)
-            return op;
-        return mk(P, 'unary_expression', op.startIndex, arg.endIndex, [op, arg]);
-    }
-    return parseTestPrimary(P, closer);
-}
-function parseTestBinary(P, closer) {
-    skipBlanks(P.L);
-    // `!` in test context binds tighter than =~/==.
-    // `[[ ! "x" =~ y ]]` → (binary_expression (unary_expression (string)) (regex))
-    // `[[ ! -f x ]]` → (unary_expression ! (unary_expression (test_operator) (word)))
-    const left = parseTestNegatablePrimary(P, closer);
-    if (!left)
-        return null;
-    skipBlanks(P.L);
-    // Binary comparison: == != =~ -eq -lt etc.
-    const c = peek(P.L);
-    const c1 = peek(P.L, 1);
-    let op = null;
-    const os = P.L.b;
-    if (c === '=' && c1 === '=') {
-        advance(P.L);
-        advance(P.L);
-        op = mk(P, '==', os, P.L.b, []);
-    }
-    else if (c === '!' && c1 === '=') {
-        advance(P.L);
-        advance(P.L);
-        op = mk(P, '!=', os, P.L.b, []);
-    }
-    else if (c === '=' && c1 === '~') {
-        advance(P.L);
-        advance(P.L);
-        op = mk(P, '=~', os, P.L.b, []);
-    }
-    else if (c === '=' && c1 !== '=') {
-        advance(P.L);
-        op = mk(P, '=', os, P.L.b, []);
-    }
-    else if (c === '<' && c1 !== '<') {
-        advance(P.L);
-        op = mk(P, '<', os, P.L.b, []);
-    }
-    else if (c === '>' && c1 !== '>') {
-        advance(P.L);
-        op = mk(P, '>', os, P.L.b, []);
-    }
-    else if (c === '-' && isIdentStart(c1)) {
-        advance(P.L);
-        while (isIdentChar(peek(P.L)))
-            advance(P.L);
-        op = mk(P, 'test_operator', os, P.L.b, []);
-    }
-    if (!op)
-        return left;
-    skipBlanks(P.L);
-    // In [[ ]], RHS of ==/!=/=/=~ gets special pattern parsing: paren counting
-    // so @(a|b|c) doesn't break on |, and segments become extglob_pattern/regex.
-    if (closer === ']]') {
-        const opText = op.type;
-        if (opText === '=~') {
-            skipBlanks(P.L);
-            // If the ENTIRE RHS is a quoted string, emit string/raw_string not
-            // regex: `[[ "$x" =~ "$y" ]]` → (binary_expression (string) (string)).
-            // If there's content after the quote (`' boop '(.*)$`), the whole RHS
-            // stays a single (regex). Peek past the quote to check.
-            const rc = peek(P.L);
-            let rhs = null;
-            if (rc === '"' || rc === "'") {
-                const save = saveLex(P.L);
-                const quoted = rc === '"'
-                    ? parseDoubleQuoted(P)
-                    : leaf(P, 'raw_string', nextToken(P.L, 'arg'));
-                // Check if RHS ends here: only whitespace then ]] or &&/|| or newline
-                let j = P.L.i;
-                while (j < P.L.len && (P.src[j] === ' ' || P.src[j] === '\t'))
-                    j++;
-                const nc = P.src[j] ?? '';
-                const nc1 = P.src[j + 1] ?? '';
-                if ((nc === ']' && nc1 === ']') ||
-                    (nc === '&' && nc1 === '&') ||
-                    (nc === '|' && nc1 === '|') ||
-                    nc === '\n' ||
-                    nc === '') {
-                    rhs = quoted;
-                }
-                else {
-                    restoreLex(P.L, save);
-                }
-            }
-            if (!rhs)
-                rhs = parseTestRegexRhs(P);
-            if (!rhs)
-                return left;
-            return mk(P, 'binary_expression', left.startIndex, rhs.endIndex, [
-                left,
-                op,
-                rhs,
-            ]);
-        }
-        // Single `=` emits (regex) per tree-sitter; `==` and `!=` emit extglob_pattern
-        if (opText === '=') {
-            const rhs = parseTestRegexRhs(P);
-            if (!rhs)
-                return left;
-            return mk(P, 'binary_expression', left.startIndex, rhs.endIndex, [
-                left,
-                op,
-                rhs,
-            ]);
-        }
-        if (opText === '==' || opText === '!=') {
-            const parts = parseTestExtglobRhs(P);
-            if (parts.length === 0)
-                return left;
-            const last = parts[parts.length - 1];
-            return mk(P, 'binary_expression', left.startIndex, last.endIndex, [
-                left,
-                op,
-                ...parts,
-            ]);
-        }
-    }
-    const right = parseTestPrimary(P, closer);
-    if (!right)
-        return left;
-    return mk(P, 'binary_expression', left.startIndex, right.endIndex, [
-        left,
-        op,
-        right,
-    ]);
-}
-// RHS of =~ in [[ ]] — scan as single (regex) node with paren/bracket counting
-// so | ( ) inside the regex don't break parsing. Stop at ]] or ws+&&/||.
-function parseTestRegexRhs(P) {
-    skipBlanks(P.L);
-    const start = P.L.b;
-    let parenDepth = 0;
-    let bracketDepth = 0;
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '\\' && P.L.i + 1 < P.L.len) {
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        if (c === '\n')
-            break;
-        if (parenDepth === 0 && bracketDepth === 0) {
-            if (c === ']' && peek(P.L, 1) === ']')
-                break;
-            if (c === ' ' || c === '\t') {
-                // Peek past blanks for ]] or &&/||
-                let j = P.L.i;
-                while (j < P.L.len && (P.L.src[j] === ' ' || P.L.src[j] === '\t'))
-                    j++;
-                const nc = P.L.src[j] ?? '';
-                const nc1 = P.L.src[j + 1] ?? '';
-                if ((nc === ']' && nc1 === ']') ||
-                    (nc === '&' && nc1 === '&') ||
-                    (nc === '|' && nc1 === '|')) {
-                    break;
-                }
-                advance(P.L);
-                continue;
-            }
-        }
-        if (c === '(')
-            parenDepth++;
-        else if (c === ')' && parenDepth > 0)
-            parenDepth--;
-        else if (c === '[')
-            bracketDepth++;
-        else if (c === ']' && bracketDepth > 0)
-            bracketDepth--;
-        advance(P.L);
-    }
-    if (P.L.b === start)
-        return null;
-    return mk(P, 'regex', start, P.L.b, []);
-}
-// RHS of ==/!=/= in [[ ]] — returns array of parts. Bare text → extglob_pattern
-// (with paren counting for @(a|b)); $(...)/${}/quoted → proper node types.
-// Multiple parts become flat children of binary_expression per tree-sitter.
-function parseTestExtglobRhs(P) {
-    skipBlanks(P.L);
-    const parts = [];
-    let segStart = P.L.b;
-    let segStartI = P.L.i;
-    let parenDepth = 0;
-    const flushSeg = () => {
-        if (P.L.i > segStartI) {
-            const text = P.src.slice(segStartI, P.L.i);
-            // Pure number stays number; everything else is extglob_pattern
-            const type = /^\d+$/.test(text) ? 'number' : 'extglob_pattern';
-            parts.push(mk(P, type, segStart, P.L.b, []));
-        }
-    };
-    while (P.L.i < P.L.len) {
-        const c = peek(P.L);
-        if (c === '\\' && P.L.i + 1 < P.L.len) {
-            advance(P.L);
-            advance(P.L);
-            continue;
-        }
-        if (c === '\n')
-            break;
-        if (parenDepth === 0) {
-            if (c === ']' && peek(P.L, 1) === ']')
-                break;
-            if (c === ' ' || c === '\t') {
-                let j = P.L.i;
-                while (j < P.L.len && (P.L.src[j] === ' ' || P.L.src[j] === '\t'))
-                    j++;
-                const nc = P.L.src[j] ?? '';
-                const nc1 = P.L.src[j + 1] ?? '';
-                if ((nc === ']' && nc1 === ']') ||
-                    (nc === '&' && nc1 === '&') ||
-                    (nc === '|' && nc1 === '|')) {
-                    break;
-                }
-                advance(P.L);
-                continue;
-            }
-        }
-        // $ " ' must be parsed even inside @( ) extglob parens — parseDollarLike
-        // consumes matching ) so parenDepth stays consistent.
-        if (c === '$') {
-            const c1 = peek(P.L, 1);
-            if (c1 === '(' ||
-                c1 === '{' ||
-                isIdentStart(c1) ||
-                SPECIAL_VARS.has(c1)) {
-                flushSeg();
-                const exp = parseDollarLike(P);
-                if (exp)
-                    parts.push(exp);
-                segStart = P.L.b;
-                segStartI = P.L.i;
-                continue;
-            }
-        }
-        if (c === '"') {
-            flushSeg();
-            parts.push(parseDoubleQuoted(P));
-            segStart = P.L.b;
-            segStartI = P.L.i;
-            continue;
-        }
-        if (c === "'") {
-            flushSeg();
-            const tok = nextToken(P.L, 'arg');
-            parts.push(leaf(P, 'raw_string', tok));
-            segStart = P.L.b;
-            segStartI = P.L.i;
-            continue;
-        }
-        if (c === '(')
-            parenDepth++;
-        else if (c === ')' && parenDepth > 0)
-            parenDepth--;
-        advance(P.L);
-    }
-    flushSeg();
-    return parts;
-}
-function parseTestPrimary(P, closer) {
-    skipBlanks(P.L);
-    // Stop at closer
-    if (closer === ']' && peek(P.L) === ']')
-        return null;
-    if (closer === ']]' && peek(P.L) === ']' && peek(P.L, 1) === ']')
-        return null;
-    return parseWord(P, 'arg');
-}
-/** Operator precedence table (higher = tighter binding). */
-const ARITH_PREC = {
-    '=': 2,
-    '+=': 2,
-    '-=': 2,
-    '*=': 2,
-    '/=': 2,
-    '%=': 2,
-    '<<=': 2,
-    '>>=': 2,
-    '&=': 2,
-    '^=': 2,
-    '|=': 2,
-    '||': 4,
-    '&&': 5,
-    '|': 6,
-    '^': 7,
-    '&': 8,
-    '==': 9,
-    '!=': 9,
-    '<': 10,
-    '>': 10,
-    '<=': 10,
-    '>=': 10,
-    '<<': 11,
-    '>>': 11,
-    '+': 12,
-    '-': 12,
-    '*': 13,
-    '/': 13,
-    '%': 13,
-    '**': 14,
-};
-/** Right-associative operators (assignment and exponent). */
-const ARITH_RIGHT_ASSOC = new Set([
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '<<=',
-    '>>=',
-    '&=',
-    '^=',
-    '|=',
-    '**',
-]);
-function parseArithExpr(P, stop, mode = 'var') {
-    return parseArithTernary(P, stop, mode);
-}
-/** Top-level: comma-separated list. arithmetic_expansion emits multiple children. */
-function parseArithCommaList(P, stop, mode = 'var') {
-    const out = [];
-    while (true) {
-        const e = parseArithTernary(P, stop, mode);
-        if (e)
-            out.push(e);
-        skipBlanks(P.L);
-        if (peek(P.L) === ',' && !isArithStop(P, stop)) {
-            advance(P.L);
-            continue;
-        }
-        break;
-    }
-    return out;
-}
-function parseArithTernary(P, stop, mode) {
-    const cond = parseArithBinary(P, stop, 0, mode);
-    if (!cond)
-        return null;
-    skipBlanks(P.L);
-    if (peek(P.L) === '?') {
-        const qs = P.L.b;
-        advance(P.L);
-        const q = mk(P, '?', qs, P.L.b, []);
-        const t = parseArithBinary(P, ':', 0, mode);
-        skipBlanks(P.L);
-        let colon;
-        if (peek(P.L) === ':') {
-            const cs = P.L.b;
-            advance(P.L);
-            colon = mk(P, ':', cs, P.L.b, []);
-        }
-        else {
-            colon = mk(P, ':', P.L.b, P.L.b, []);
-        }
-        const f = parseArithTernary(P, stop, mode);
-        const last = f ?? colon;
-        const kids = [cond, q];
-        if (t)
-            kids.push(t);
-        kids.push(colon);
-        if (f)
-            kids.push(f);
-        return mk(P, 'ternary_expression', cond.startIndex, last.endIndex, kids);
-    }
-    return cond;
-}
-/** Scan next arithmetic binary operator; returns [text, length] or null. */
-function scanArithOp(P) {
-    const c = peek(P.L);
-    const c1 = peek(P.L, 1);
-    const c2 = peek(P.L, 2);
-    // 3-char: <<= >>=
-    if (c === '<' && c1 === '<' && c2 === '=')
-        return ['<<=', 3];
-    if (c === '>' && c1 === '>' && c2 === '=')
-        return ['>>=', 3];
-    // 2-char
-    if (c === '*' && c1 === '*')
-        return ['**', 2];
-    if (c === '<' && c1 === '<')
-        return ['<<', 2];
-    if (c === '>' && c1 === '>')
-        return ['>>', 2];
-    if (c === '=' && c1 === '=')
-        return ['==', 2];
-    if (c === '!' && c1 === '=')
-        return ['!=', 2];
-    if (c === '<' && c1 === '=')
-        return ['<=', 2];
-    if (c === '>' && c1 === '=')
-        return ['>=', 2];
-    if (c === '&' && c1 === '&')
-        return ['&&', 2];
-    if (c === '|' && c1 === '|')
-        return ['||', 2];
-    if (c === '+' && c1 === '=')
-        return ['+=', 2];
-    if (c === '-' && c1 === '=')
-        return ['-=', 2];
-    if (c === '*' && c1 === '=')
-        return ['*=', 2];
-    if (c === '/' && c1 === '=')
-        return ['/=', 2];
-    if (c === '%' && c1 === '=')
-        return ['%=', 2];
-    if (c === '&' && c1 === '=')
-        return ['&=', 2];
-    if (c === '^' && c1 === '=')
-        return ['^=', 2];
-    if (c === '|' && c1 === '=')
-        return ['|=', 2];
-    // 1-char — but NOT ++ -- (those are pre/postfix)
-    if (c === '+' && c1 !== '+')
-        return ['+', 1];
-    if (c === '-' && c1 !== '-')
-        return ['-', 1];
-    if (c === '*')
-        return ['*', 1];
-    if (c === '/')
-        return ['/', 1];
-    if (c === '%')
-        return ['%', 1];
-    if (c === '<')
-        return ['<', 1];
-    if (c === '>')
-        return ['>', 1];
-    if (c === '&')
-        return ['&', 1];
-    if (c === '|')
-        return ['|', 1];
-    if (c === '^')
-        return ['^', 1];
-    if (c === '=')
-        return ['=', 1];
-    return null;
-}
-/** Precedence-climbing binary expression parser. */
-function parseArithBinary(P, stop, minPrec, mode) {
-    let left = parseArithUnary(P, stop, mode);
-    if (!left)
-        return null;
-    while (true) {
-        skipBlanks(P.L);
-        if (isArithStop(P, stop))
-            break;
-        if (peek(P.L) === ',')
-            break;
-        const opInfo = scanArithOp(P);
-        if (!opInfo)
-            break;
-        const [opText, opLen] = opInfo;
-        const prec = ARITH_PREC[opText];
-        if (prec === undefined || prec < minPrec)
-            break;
-        const os = P.L.b;
-        for (let k = 0; k < opLen; k++)
-            advance(P.L);
-        const op = mk(P, opText, os, P.L.b, []);
-        const nextMin = ARITH_RIGHT_ASSOC.has(opText) ? prec : prec + 1;
-        const right = parseArithBinary(P, stop, nextMin, mode);
-        if (!right)
-            break;
-        left = mk(P, 'binary_expression', left.startIndex, right.endIndex, [
-            left,
-            op,
-            right,
-        ]);
-    }
-    return left;
-}
-function parseArithUnary(P, stop, mode) {
-    skipBlanks(P.L);
-    if (isArithStop(P, stop))
-        return null;
-    const c = peek(P.L);
-    const c1 = peek(P.L, 1);
-    // Prefix ++ --
-    if ((c === '+' && c1 === '+') || (c === '-' && c1 === '-')) {
-        const s = P.L.b;
-        advance(P.L);
-        advance(P.L);
-        const op = mk(P, c + c1, s, P.L.b, []);
-        const inner = parseArithUnary(P, stop, mode);
-        if (!inner)
-            return op;
-        return mk(P, 'unary_expression', op.startIndex, inner.endIndex, [op, inner]);
-    }
-    if (c === '-' || c === '+' || c === '!' || c === '~') {
-        // In 'word'/'assign' mode (c-style for head), `-N` is a single number
-        // literal per tree-sitter, not unary_expression. 'var' mode uses unary.
-        if (mode !== 'var' && c === '-' && isDigit(c1)) {
-            const s = P.L.b;
-            advance(P.L);
-            while (isDigit(peek(P.L)))
-                advance(P.L);
-            return mk(P, 'number', s, P.L.b, []);
-        }
-        const s = P.L.b;
-        advance(P.L);
-        const op = mk(P, c, s, P.L.b, []);
-        const inner = parseArithUnary(P, stop, mode);
-        if (!inner)
-            return op;
-        return mk(P, 'unary_expression', op.startIndex, inner.endIndex, [op, inner]);
-    }
-    return parseArithPostfix(P, stop, mode);
-}
-function parseArithPostfix(P, stop, mode) {
-    const prim = parseArithPrimary(P, stop, mode);
-    if (!prim)
-        return null;
-    const c = peek(P.L);
-    const c1 = peek(P.L, 1);
-    if ((c === '+' && c1 === '+') || (c === '-' && c1 === '-')) {
-        const s = P.L.b;
-        advance(P.L);
-        advance(P.L);
-        const op = mk(P, c + c1, s, P.L.b, []);
-        return mk(P, 'postfix_expression', prim.startIndex, op.endIndex, [prim, op]);
-    }
-    return prim;
-}
-function parseArithPrimary(P, stop, mode) {
-    skipBlanks(P.L);
-    if (isArithStop(P, stop))
-        return null;
-    const c = peek(P.L);
-    if (c === '(') {
-        const s = P.L.b;
-        advance(P.L);
-        const open = mk(P, '(', s, P.L.b, []);
-        // Parenthesized expression may contain comma-separated exprs
-        const inners = parseArithCommaList(P, ')', mode);
-        skipBlanks(P.L);
-        let close;
-        if (peek(P.L) === ')') {
-            const cs = P.L.b;
-            advance(P.L);
-            close = mk(P, ')', cs, P.L.b, []);
-        }
-        else {
-            close = mk(P, ')', P.L.b, P.L.b, []);
-        }
-        return mk(P, 'parenthesized_expression', open.startIndex, close.endIndex, [
-            open,
-            ...inners,
-            close,
-        ]);
-    }
-    if (c === '"') {
-        return parseDoubleQuoted(P);
-    }
-    if (c === '$') {
-        return parseDollarLike(P);
-    }
-    if (isDigit(c)) {
-        const s = P.L.b;
-        while (isDigit(peek(P.L)))
-            advance(P.L);
-        // Hex: 0x1f
-        if (P.L.b - s === 1 &&
-            c === '0' &&
-            (peek(P.L) === 'x' || peek(P.L) === 'X')) {
-            advance(P.L);
-            while (isHexDigit(peek(P.L)))
-                advance(P.L);
-        }
-        // Base notation: BASE#DIGITS e.g. 2#1010, 16#ff
-        else if (peek(P.L) === '#') {
-            advance(P.L);
-            while (isBaseDigit(peek(P.L)))
-                advance(P.L);
-        }
-        return mk(P, 'number', s, P.L.b, []);
-    }
-    if (isIdentStart(c)) {
-        const s = P.L.b;
-        while (isIdentChar(peek(P.L)))
-            advance(P.L);
-        const nc = peek(P.L);
-        // Assignment in 'assign' mode (c-style for init): emit variable_assignment
-        // so chained `a = b = c = 1` nests correctly. Other modes treat `=` as a
-        // binary_expression operator via the precedence table.
-        if (mode === 'assign') {
-            skipBlanks(P.L);
-            const ac = peek(P.L);
-            const ac1 = peek(P.L, 1);
-            if (ac === '=' && ac1 !== '=') {
-                const vn = mk(P, 'variable_name', s, P.L.b, []);
-                const es = P.L.b;
-                advance(P.L);
-                const eq = mk(P, '=', es, P.L.b, []);
-                // RHS may itself be another assignment (chained)
-                const val = parseArithTernary(P, stop, mode);
-                const end = val ? val.endIndex : eq.endIndex;
-                const kids = val ? [vn, eq, val] : [vn, eq];
-                return mk(P, 'variable_assignment', s, end, kids);
-            }
-        }
-        // Subscript
-        if (nc === '[') {
-            const vn = mk(P, 'variable_name', s, P.L.b, []);
-            const brS = P.L.b;
-            advance(P.L);
-            const brOpen = mk(P, '[', brS, P.L.b, []);
-            const idx = parseArithTernary(P, ']', 'var') ?? parseDollarLike(P);
-            skipBlanks(P.L);
-            let brClose;
-            if (peek(P.L) === ']') {
-                const cs = P.L.b;
-                advance(P.L);
-                brClose = mk(P, ']', cs, P.L.b, []);
-            }
-            else {
-                brClose = mk(P, ']', P.L.b, P.L.b, []);
-            }
-            const kids = idx ? [vn, brOpen, idx, brClose] : [vn, brOpen, brClose];
-            return mk(P, 'subscript', s, brClose.endIndex, kids);
-        }
-        // Bare identifier: variable_name in 'var' mode, word in 'word'/'assign' mode.
-        // 'assign' mode falls through to word when no `=` follows (c-style for
-        // cond/update clauses: `c<=5` → binary_expression(word, number)).
-        const identType = mode === 'var' ? 'variable_name' : 'word';
-        return mk(P, identType, s, P.L.b, []);
-    }
-    return null;
-}
-function isArithStop(P, stop) {
-    const c = peek(P.L);
-    if (stop === '))')
-        return c === ')' && peek(P.L, 1) === ')';
-    if (stop === ')')
-        return c === ')';
-    if (stop === ';')
-        return c === ';';
-    if (stop === ':')
-        return c === ':';
-    if (stop === ']')
-        return c === ']';
-    if (stop === '}')
-        return c === '}';
-    if (stop === ':}')
-        return c === ':' || c === '}';
-    return c === '' || c === '\n';
-}