@ykdz/template 0.0.42 → 0.1.0-experimental.1

package/node_modules/unbash/dist/parser.js

@@ -1,1295 +0,0 @@
-import { hasEmbeddedWordStructure, LexContext, MAX_SYNTAX_NESTING, Token, Lexer, TokenValue } from "./lexer.js";
-import { parseArithmeticExpression } from "./arithmetic.js";
-import { computeWordParts, computeEmbeddedWordParts, computeHereDocBodyParts } from "./parts.js";
-import { WordImpl } from "./word.js";
-import { AssignmentImpl } from "./assignment.js";
-import { CommandImpl } from "./command.js";
-import { HereDocBodyImpl } from "./heredoc.js";
-WordImpl._resolveWord = computeWordParts;
-HereDocBodyImpl._resolveParts = computeHereDocBodyParts;
-function isDeclarationCommand(name) {
-    switch (name.length) {
-        case 5:
-            return name === "local" || name === "alias";
-        case 6:
-            return name === "export";
-        case 7:
-            return name === "declare" || name === "typeset";
-        case 8:
-            return name === "readonly";
-        default:
-            return false;
-    }
-}
-class ArithmeticCommandImpl {
-    type = "ArithmeticCommand";
-    pos;
-    end;
-    body;
-    #source;
-    #depth;
-    #expression = null;
-    constructor(pos, end, body, source, depth) {
-        this.pos = pos;
-        this.end = end;
-        this.body = body;
-        this.#source = source;
-        this.#depth = depth;
-    }
-    get expression() {
-        if (this.#expression === null) {
-            this.#expression = parseArithmeticWithParts(this.body, this.pos + 2, this.#source, this.#depth);
-        }
-        return this.#expression;
-    }
-    set expression(v) {
-        this.#expression = v ?? undefined;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            pos: this.pos,
-            end: this.end,
-            expression: this.expression,
-            body: this.body,
-        };
-    }
-}
-class ArithmeticForImpl {
-    type = "ArithmeticFor";
-    pos;
-    end;
-    body;
-    #initStr;
-    #testStr;
-    #updateStr;
-    #initPos;
-    #testPos;
-    #updatePos;
-    #source;
-    #depth;
-    #initialize = null;
-    #test = null;
-    #update = null;
-    constructor(pos, end, body, initStr, testStr, updateStr, initPos, testPos, updatePos, source, depth) {
-        this.pos = pos;
-        this.end = end;
-        this.body = body;
-        this.#initStr = initStr;
-        this.#testStr = testStr;
-        this.#updateStr = updateStr;
-        this.#initPos = initPos;
-        this.#testPos = testPos;
-        this.#updatePos = updatePos;
-        this.#source = source;
-        this.#depth = depth;
-    }
-    get initialize() {
-        if (this.#initialize === null) {
-            if (this.#initStr) {
-                this.#initialize = parseArithmeticWithParts(this.#initStr, this.#initPos, this.#source, this.#depth);
-            }
-            else {
-                this.#initialize = undefined;
-            }
-        }
-        return this.#initialize;
-    }
-    set initialize(v) {
-        this.#initialize = v ?? undefined;
-    }
-    get test() {
-        if (this.#test === null) {
-            if (this.#testStr) {
-                this.#test = parseArithmeticWithParts(this.#testStr, this.#testPos, this.#source, this.#depth);
-            }
-            else {
-                this.#test = undefined;
-            }
-        }
-        return this.#test;
-    }
-    set test(v) {
-        this.#test = v ?? undefined;
-    }
-    get update() {
-        if (this.#update === null) {
-            if (this.#updateStr) {
-                this.#update = parseArithmeticWithParts(this.#updateStr, this.#updatePos, this.#source, this.#depth);
-            }
-            else {
-                this.#update = undefined;
-            }
-        }
-        return this.#update;
-    }
-    set update(v) {
-        this.#update = v ?? undefined;
-    }
-    toJSON() {
-        return {
-            type: this.type,
-            pos: this.pos,
-            end: this.end,
-            initialize: this.initialize,
-            test: this.test,
-            update: this.update,
-            body: this.body,
-        };
-    }
-}
-const CASE_TERMINATORS = {
-    [Token.DoubleSemi]: ";;",
-    [Token.SemiAmp]: ";&",
-    [Token.DoubleSemiAmp]: ";;&",
-};
-const REDIRECT_OPS = {
-    ">": ">",
-    ">>": ">>",
-    "<": "<",
-    "<>": "<>",
-    "<&": "<&",
-    ">&": ">&",
-    ">|": ">|",
-    "&>": "&>",
-    "&>>": "&>>",
-};
-function parseArithmeticWithParts(body, offset, source, depth = 0) {
-    if (!hasEmbeddedWordStructure(source, offset, offset + body.length)) {
-        return parseArithmeticExpression(body, offset) ?? undefined;
-    }
-    const commandExpansions = [];
-    const embeddedWords = [];
-    const lexer = new Lexer(source);
-    const expression = parseArithmeticExpression(body, offset, {
-        commandExpansions,
-        embeddedWords,
-        findClosingBracket: (start, end) => lexer.findClosingBracket(start, end),
-        findClosingBrace: (start, end) => lexer.findClosingBrace(start, end),
-        findClosingParenthesis: (start, end) => lexer.findClosingParenthesis(start, end),
-        findArithmeticExpansionEnd: (start, end) => lexer.findArithmeticExpansionEnd(start, end),
-        findArithmeticWordEnd: (start, end) => lexer.findArithmeticWordEnd(start, end),
-    }) ?? undefined;
-    for (const node of commandExpansions) {
-        if (depth <= MAX_SYNTAX_NESTING) {
-            node.script = parseRegion(source, node.pos + 2, node.end - 1, depth + 1, true);
-        }
-    }
-    for (const node of embeddedWords)
-        node.parts = computeEmbeddedWordParts(source, node, depth);
-    return expression;
-}
-// Lookup tables for O(1) token classification (replaces sequential comparisons)
-const listTerminators = new Uint8Array(37);
-listTerminators[Token.EOF] = 1;
-listTerminators[Token.RParen] = 1;
-listTerminators[Token.RBrace] = 1;
-listTerminators[Token.Then] = 1;
-listTerminators[Token.Else] = 1;
-listTerminators[Token.Elif] = 1;
-listTerminators[Token.Fi] = 1;
-listTerminators[Token.Do] = 1;
-listTerminators[Token.Done] = 1;
-listTerminators[Token.Esac] = 1;
-listTerminators[Token.DoubleSemi] = 1;
-listTerminators[Token.SemiAmp] = 1;
-listTerminators[Token.DoubleSemiAmp] = 1;
-// After one of these Bash is at a command-start position, the only place a reserved-word
-// terminator may follow with no separator.
-const compoundClosers = new Uint8Array(37);
-compoundClosers[Token.RParen] = 1;
-compoundClosers[Token.RBrace] = 1;
-compoundClosers[Token.DblRBracket] = 1;
-compoundClosers[Token.Fi] = 1;
-compoundClosers[Token.Done] = 1;
-compoundClosers[Token.Esac] = 1;
-compoundClosers[Token.ArithCmd] = 1;
-// Inside `[[ ]]` only an unquoted `!` negates; `'!'` and `\!` are ordinary operands.
-function isTestNegation(t) {
-    return t.token === Token.Word && t.keywordEligible && t.value === "!";
-}
-const commandStarts = new Uint8Array(37);
-commandStarts[Token.Word] = 1;
-commandStarts[Token.Assignment] = 1;
-commandStarts[Token.Bang] = 1;
-commandStarts[Token.LParen] = 1;
-commandStarts[Token.LBrace] = 1;
-commandStarts[Token.DblLBracket] = 1;
-commandStarts[Token.If] = 1;
-commandStarts[Token.For] = 1;
-commandStarts[Token.While] = 1;
-commandStarts[Token.Until] = 1;
-commandStarts[Token.Case] = 1;
-commandStarts[Token.Function] = 1;
-commandStarts[Token.Select] = 1;
-commandStarts[Token.ArithCmd] = 1;
-commandStarts[Token.Coproc] = 1;
-commandStarts[Token.Redirect] = 1;
-const UNARY_TEST_OPS = {
-    "-a": 1,
-    "-b": 1,
-    "-c": 1,
-    "-d": 1,
-    "-e": 1,
-    "-f": 1,
-    "-g": 1,
-    "-h": 1,
-    "-k": 1,
-    "-p": 1,
-    "-r": 1,
-    "-s": 1,
-    "-t": 1,
-    "-u": 1,
-    "-v": 1,
-    "-w": 1,
-    "-x": 1,
-    "-z": 1,
-    "-n": 1,
-    "-o": 1,
-    "-N": 1,
-    "-S": 1,
-    "-L": 1,
-    "-G": 1,
-    "-O": 1,
-    "-R": 1,
-};
-const BINARY_TEST_OPS = {
-    "==": 1,
-    "!=": 1,
-    "=~": 1,
-    "=": 1,
-    "-eq": 1,
-    "-ne": 1,
-    "-lt": 1,
-    "-le": 1,
-    "-gt": 1,
-    "-ge": 1,
-    "-nt": 1,
-    "-ot": 1,
-    "-ef": 1,
-    "<": 1,
-    ">": 1,
-};
-const EMPTY_REDIRECTS = [];
-export function parse(source) {
-    return new Parser(source, 0, source.length).run();
-}
-// Parse a [start, end) window of `source` in place, so the resulting nodes index the original
-// source directly. Used to resolve substitution scripts with absolute offsets; not public API.
-export function parseRegion(source, start, end, depth = 0, parenBoundary = false) {
-    return new Parser(source, start, end, depth, parenBoundary).run();
-}
-class Parser {
-    tok;
-    source;
-    start;
-    end;
-    depth;
-    errors = null;
-    syntaxDepth = 0;
-    // `depth` counts the substitution scripts (and sub-fields) enclosing this region; it
-    // shares the MAX_SYNTAX_NESTING budget with the lexer's lazy word-part materialization.
-    constructor(source, start, end, depth = 0, parenBoundary = false) {
-        this.tok = new Lexer(source, start, end, parenBoundary);
-        this.tok._nestingDepth = depth;
-        this.source = source;
-        this.start = start;
-        this.end = end;
-        this.depth = depth;
-    }
-    run() {
-        const start = this.start;
-        // The boundary script one level past the budget still parses (one level is cheap and
-        // iterative) but is flagged: everything below it stays unresolved.
-        if (this.depth > MAX_SYNTAX_NESTING)
-            this.error("maximum substitution nesting depth exceeded", start);
-        let shebang;
-        if (start === 0 && this.source.charCodeAt(0) === 35 && this.source.charCodeAt(1) === 33) {
-            const nl = this.source.indexOf("\n");
-            shebang = nl === -1 ? this.source : this.source.slice(0, nl);
-        }
-        const commands = this.list();
-        for (;;) {
-            const unexpected = this.tok.peek(LexContext.CommandStart);
-            if (unexpected.token === Token.EOF)
-                break;
-            this.error(`unexpected token '${unexpected.value}'`, unexpected.pos);
-            // `In` cannot join `listTerminators`: `list()` shares it, and `in` must not terminate a
-            // list inside `for`/`case`.
-            if (!listTerminators[unexpected.token] && unexpected.token !== Token.In)
-                break;
-            this.tok.next(LexContext.CommandStart);
-            let separator = this.tok.peek(LexContext.CommandStart).token;
-            if (separator !== Token.Semi && separator !== Token.Newline && separator !== Token.Amp)
-                break;
-            while (separator === Token.Semi || separator === Token.Newline || separator === Token.Amp) {
-                this.tok.next(LexContext.CommandStart);
-                separator = this.tok.peek(LexContext.CommandStart).token;
-            }
-            const recovered = this.list();
-            for (let i = 0; i < recovered.length; i++)
-                commands.push(recovered[i]);
-        }
-        const lexerErrors = this.tok._errors;
-        if (lexerErrors !== null && lexerErrors.length > 0) {
-            const errors = this.errors ?? (this.errors = []);
-            for (let i = 0; i < lexerErrors.length; i++)
-                errors.push(lexerErrors[i]);
-        }
-        if (this.errors !== null && this.errors.length > 1)
-            this.errors.sort((a, b) => a.pos - b.pos);
-        return {
-            type: "Script",
-            pos: start,
-            end: this.end,
-            shebang,
-            commands,
-            errors: this.errors ?? undefined,
-        };
-    }
-    error(message, pos) {
-        (this.errors ?? (this.errors = [])).push({ message, pos });
-    }
-    skipSemi() {
-        if (this.tok.peek(LexContext.Normal).token === Token.Semi)
-            this.tok.next(LexContext.Normal);
-    }
-    accept(token, ctx = LexContext.Normal) {
-        if (this.tok.peek(ctx).token === token)
-            return this.tok.next(ctx);
-        return null;
-    }
-    acceptEnd(token, ctx = LexContext.Normal) {
-        if (this.tok.peek(ctx).token === token)
-            return this.tok.next(ctx).end;
-        return -1;
-    }
-    skipNewlines(ctx = LexContext.Normal) {
-        while (this.tok.peek(ctx).token === Token.Newline)
-            this.tok.next(ctx);
-    }
-    makeStatement(command) {
-        return {
-            type: "Statement",
-            pos: command.pos,
-            end: command.end,
-            command,
-            background: undefined,
-        };
-    }
-    // list := and_or ((';' | '&' | NEWLINE) and_or)* [';' | '&' | NEWLINE]
-    list() {
-        const commands = [];
-        this.skipNewlines(LexContext.CommandStart);
-        let t = this.tok.peek(LexContext.CommandStart).token;
-        if (listTerminators[t] || !commandStarts[t])
-            return commands;
-        const first = this.andOr();
-        if (first)
-            commands.push(this.makeStatement(first));
-        for (;;) {
-            t = this.tok.peekFollow(compoundClosers).token;
-            if (t !== Token.Semi && t !== Token.Newline && t !== Token.Amp)
-                break;
-            const isBackground = t === Token.Amp;
-            const sepEnd = this.tok.next(LexContext.Normal).end;
-            if (isBackground) {
-                const stmt = commands[commands.length - 1];
-                stmt.background = true;
-                stmt.end = sepEnd;
-            }
-            this.skipNewlines(LexContext.CommandStart);
-            t = this.tok.peek(LexContext.CommandStart).token;
-            if (listTerminators[t] || !commandStarts[t])
-                break;
-            const node = this.andOr();
-            if (node)
-                commands.push(this.makeStatement(node));
-        }
-        return commands;
-    }
-    // and_or := pipeline (('&&' | '||') newlines pipeline)*
-    andOr() {
-        const first = this.pipeline();
-        if (!first)
-            return null;
-        let t = this.tok.peek(LexContext.Normal).token;
-        if (t !== Token.And && t !== Token.Or)
-            return first;
-        const commands = [first];
-        const operators = [];
-        do {
-            const operatorToken = this.tok.next(LexContext.Normal);
-            const operator = operatorToken.token === Token.And ? "&&" : "||";
-            this.skipNewlines(LexContext.CommandStart);
-            const next = this.pipeline();
-            if (!next) {
-                this.error(`expected command after '${operator}'`, operatorToken.end);
-                break;
-            }
-            operators.push(operator);
-            commands.push(next);
-            t = this.tok.peek(LexContext.Normal).token;
-        } while (t === Token.And || t === Token.Or);
-        return {
-            type: "AndOr",
-            pos: first.pos,
-            end: commands[commands.length - 1].end,
-            commands,
-            operators,
-        };
-    }
-    withRedirects(command) {
-        const redirects = this.collectTrailingRedirects();
-        if (redirects.length === 0)
-            return command;
-        return { type: "Redirected", pos: command.pos, end: redirects[redirects.length - 1].end, command, redirects };
-    }
-    pipeline() {
-        let prefixes;
-        let exceeded = false;
-        for (;;) {
-            const token = this.tok.peek(LexContext.CommandStart);
-            const isTime = token.token === Token.Word && token.keywordEligible && token.value === "time";
-            if (token.token !== Token.Bang && !isTime)
-                break;
-            const prefix = this.tok.next(LexContext.CommandStart);
-            const pos = prefix.pos;
-            const keywordEnd = prefix.end;
-            let posix;
-            let endOfOptions;
-            if (isTime) {
-                let flag = this.tok.peek(LexContext.CommandStart);
-                if (flag.token === Token.Word && flag.keywordEligible && flag.value === "-p") {
-                    this.tok.next(LexContext.CommandStart);
-                    posix = { pos: flag.pos, end: flag.end };
-                    flag = this.tok.peek(LexContext.CommandStart);
-                }
-                if (flag.token === Token.Word && flag.keywordEligible && flag.value === "--") {
-                    this.tok.next(LexContext.CommandStart);
-                    endOfOptions = { pos: flag.pos, end: flag.end };
-                }
-            }
-            if (prefixes === undefined)
-                prefixes = [];
-            if (prefixes.length + this.syntaxDepth === MAX_SYNTAX_NESTING) {
-                if (!exceeded)
-                    this.error("maximum pipeline prefix nesting depth exceeded", pos);
-                exceeded = true;
-                continue;
-            }
-            prefixes.push(isTime
-                ? {
-                    type: "Time",
-                    pos,
-                    end: endOfOptions?.end ?? posix?.end ?? keywordEnd,
-                    keywordEnd,
-                    posix,
-                    endOfOptions,
-                    command: undefined,
-                }
-                : { type: "Negation", pos, end: keywordEnd, keywordEnd, command: undefined });
-        }
-        if (!prefixes)
-            return this.pipelineCommands();
-        this.syntaxDepth += prefixes.length;
-        let command = this.pipelineCommands();
-        this.syntaxDepth -= prefixes.length;
-        for (let i = prefixes.length - 1; i >= 0; i--) {
-            const prefix = prefixes[i];
-            prefix.command = command ?? undefined;
-            if (command)
-                prefix.end = command.end;
-            command = prefix;
-        }
-        return command;
-    }
-    pipelineCommands() {
-        const first = this.command();
-        if (!first)
-            return null;
-        if (this.tok.peek(LexContext.Normal).token !== Token.Pipe)
-            return first;
-        const commands = [first];
-        const operators = [];
-        while (this.tok.peek(LexContext.Normal).token === Token.Pipe) {
-            const pipeToken = this.tok.next(LexContext.Normal);
-            const operator = pipeToken.value === "|&" ? "|&" : "|";
-            this.skipNewlines(LexContext.CommandStart);
-            const cmd = this.command();
-            if (!cmd) {
-                this.error(`expected command after '${operator}'`, pipeToken.end);
-                break;
-            }
-            operators.push(operator);
-            commands.push(cmd);
-        }
-        if (commands.length === 1) {
-            return commands[0];
-        }
-        const pipeline = {
-            type: "Pipeline",
-            pos: first.pos,
-            end: commands[commands.length - 1].end,
-            commands,
-            operators,
-        };
-        return pipeline;
-    }
-    // command := compound_command | function_def | simple_command
-    command() {
-        let compound;
-        switch (this.tok.peek(LexContext.CommandStart).token) {
-            case Token.LParen:
-                compound = this.subshell();
-                break;
-            case Token.LBrace:
-                compound = this.braceGroup();
-                break;
-            case Token.If:
-                compound = this.ifClause();
-                break;
-            case Token.For:
-                compound = this.forClause();
-                break;
-            case Token.While:
-                compound = this.whileClause();
-                break;
-            case Token.Until:
-                compound = this.untilClause();
-                break;
-            case Token.Case:
-                compound = this.caseClause();
-                break;
-            case Token.Function:
-                return this.functionDef();
-            case Token.Select:
-                compound = this.selectClause();
-                break;
-            case Token.DblLBracket:
-                compound = this.testCommand();
-                break;
-            case Token.ArithCmd:
-                compound = this.arithCommand();
-                break;
-            case Token.Coproc:
-                return this.coprocCommand();
-            case Token.Word:
-            case Token.Assignment:
-            case Token.Redirect:
-                return this.simpleCommandOrFunction();
-            default:
-                return null;
-        }
-        return this.withRedirects(compound);
-    }
-    collectTrailingRedirects() {
-        let redirects = EMPTY_REDIRECTS;
-        while (this.tok.peekFollow(compoundClosers).token === Token.Redirect) {
-            if (redirects === EMPTY_REDIRECTS)
-                redirects = [];
-            redirects.push(this.readRedirect(LexContext.Normal));
-        }
-        return redirects;
-    }
-    // arith_command := (( expr ))
-    arithCommand() {
-        const tok = this.tok.next(LexContext.CommandStart);
-        return new ArithmeticCommandImpl(tok.pos, tok.end, tok.value, this.source, this.depth);
-    }
-    // coproc := COPROC ([name] compound_command [redirections] | simple_command)
-    coprocCommand() {
-        const start = this.tok.next(LexContext.CommandStart);
-        const pos = start.pos;
-        const first = this.tok.peek(LexContext.CommandStart);
-        let name;
-        // Only a compound command can follow a coprocess name. Decide before parsing
-        // a simple command so its assignments and reserved words use the actual name.
-        if (first.token === Token.Word) {
-            const lookahead = new Lexer(this.source, first.end, this.end);
-            lookahead._nestingDepth = this.depth;
-            switch (lookahead.peek(LexContext.CommandStart).token) {
-                case Token.LParen:
-                    // `name ( )` opens a function definition, not a subshell body after a name.
-                    lookahead.next(LexContext.CommandStart);
-                    if (lookahead.peek(LexContext.Normal).token !== Token.RParen)
-                        name = this.readWord(LexContext.CommandStart);
-                    break;
-                case Token.LBrace:
-                case Token.If:
-                case Token.For:
-                case Token.While:
-                case Token.Until:
-                case Token.Case:
-                case Token.Select:
-                case Token.DblLBracket:
-                case Token.ArithCmd:
-                    name = this.readWord(LexContext.CommandStart);
-            }
-        }
-        const cmd = this.command();
-        if (cmd && cmd.type !== "Function" && cmd.type !== "Coproc") {
-            return { type: "Coproc", pos, end: cmd.end, name, body: cmd };
-        }
-        this.error("expected command after 'coproc'", cmd?.pos ?? start.end);
-        const body = cmd
-            ? this.makeCompoundList([this.makeStatement(cmd)])
-            : { type: "CompoundList", pos: start.end, end: start.end, commands: [] };
-        return { type: "Coproc", pos, end: body.end, name, body };
-    }
-    // subshell := '(' list ')'
-    subshell() {
-        return this.subshellBody(this.tok.next(LexContext.CommandStart).pos);
-    }
-    // Continues a subshell whose '(' the caller already consumed.
-    subshellBody(pos) {
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error("maximum subshell nesting depth exceeded", pos);
-            const closeEnd = this.tok.skipSubshellBody();
-            if (closeEnd < 0)
-                this.error("expected ')' to close subshell", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return { type: "Subshell", pos, end, body: this.makeCompoundList([]) };
-        }
-        this.syntaxDepth++;
-        const commands = this.list();
-        this.syntaxDepth--;
-        if (commands.length === 0)
-            this.error("expected command in subshell", pos);
-        const closeEnd = this.acceptEnd(Token.RParen, LexContext.Normal);
-        if (closeEnd < 0)
-            this.error("expected ')' to close subshell", this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        return { type: "Subshell", pos, end, body: this.makeCompoundList(commands) };
-    }
-    // brace_group := '{' list '}'
-    braceGroup() {
-        const pos = this.tok.next(LexContext.CommandStart).pos;
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error("maximum brace group nesting depth exceeded", pos);
-            const closeEnd = this.tok.skipCompoundBody(Token.RBrace);
-            if (closeEnd < 0)
-                this.error("expected '}' to close brace group", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return { type: "BraceGroup", pos, end, body: this.makeCompoundList([]) };
-        }
-        this.syntaxDepth++;
-        const commands = this.list();
-        this.syntaxDepth--;
-        if (commands.length === 0)
-            this.error("expected command in brace group", pos);
-        const closeEnd = this.acceptEnd(Token.RBrace, LexContext.Normal);
-        if (closeEnd < 0)
-            this.error("expected '}' to close brace group", this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        return { type: "BraceGroup", pos, end, body: this.makeCompoundList(commands) };
-    }
-    // if_clause := IF list THEN list (ELIF list THEN list)* [ELSE list] FI
-    ifClause() {
-        const pos = this.tok.next(LexContext.CommandStart).pos;
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error("maximum if nesting depth exceeded", pos);
-            const closeEnd = this.tok.skipCompoundBody(Token.Fi);
-            if (closeEnd < 0)
-                this.error("expected 'fi' to close 'if'", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return {
-                type: "If",
-                pos,
-                end,
-                clause: this.makeCompoundList([]),
-                then: this.makeCompoundList([]),
-                else: undefined,
-            };
-        }
-        this.syntaxDepth++;
-        let firstBranch;
-        let lastBranch;
-        let branchPos = pos;
-        let clause;
-        let then_;
-        for (;;) {
-            clause = this.makeCompoundList(this.list());
-            this.skipSemi();
-            const thenToken = this.accept(Token.Then, LexContext.CommandStart);
-            if (!thenToken)
-                this.error("expected 'then'", this.tok.getPos());
-            const thenCommands = this.list();
-            if (thenToken && thenCommands.length === 0)
-                this.error("expected command after 'then'", this.tok.peek(LexContext.CommandStart).pos);
-            then_ = this.makeCompoundList(thenCommands);
-            this.skipSemi();
-            const elif = this.accept(Token.Elif, LexContext.CommandStart);
-            if (!elif)
-                break;
-            const branch = {
-                type: "If",
-                pos: branchPos,
-                end: branchPos,
-                clause,
-                then: then_,
-                else: undefined,
-            };
-            if (lastBranch)
-                lastBranch.else = branch;
-            else
-                firstBranch = branch;
-            lastBranch = branch;
-            branchPos = elif.pos;
-        }
-        let else_;
-        let end;
-        if (this.accept(Token.Else, LexContext.CommandStart)) {
-            else_ = this.makeCompoundList(this.list());
-            this.skipSemi();
-            const closeEnd = this.acceptEnd(Token.Fi, LexContext.CommandStart);
-            if (closeEnd < 0)
-                this.error("expected 'fi' to close 'if'", this.tok.getPos());
-            end = closeEnd >= 0 ? closeEnd : branchPos;
-        }
-        else {
-            const closeEnd = this.acceptEnd(Token.Fi, LexContext.CommandStart);
-            if (closeEnd < 0)
-                this.error("expected 'fi' to close 'if'", this.tok.getPos());
-            end = closeEnd >= 0 ? closeEnd : branchPos;
-        }
-        this.syntaxDepth--;
-        const finalBranch = { type: "If", pos: branchPos, end, clause, then: then_, else: else_ };
-        if (!firstBranch)
-            return finalBranch;
-        lastBranch.else = finalBranch;
-        let branch = firstBranch;
-        while (branch?.type === "If") {
-            branch.end = end;
-            branch = branch.else;
-        }
-        return firstBranch;
-    }
-    // for_clause := FOR word [IN word* (';'|NL)] DO list DONE
-    //            | FOR '((' expr '))' [';'|NL] DO list DONE
-    forClause() {
-        const pos = this.tok.next(LexContext.CommandStart).pos;
-        if (this.tok.peek(LexContext.Normal).token === Token.LParen) {
-            return this.cStyleFor(pos);
-        }
-        const name = this.readWord(LexContext.Normal);
-        let wordlist;
-        this.skipNewlines(LexContext.CommandStart);
-        if (this.tok.peek(LexContext.CommandStart).token === Token.In) {
-            this.tok.next(LexContext.CommandStart);
-            wordlist = [];
-            while (this.tok.peek(LexContext.Normal).token === Token.Word) {
-                wordlist.push(this.readWord(LexContext.Normal));
-            }
-        }
-        this.skipSemi();
-        this.skipNewlines(LexContext.CommandStart);
-        if (this.tok.peek(LexContext.CommandStart).token === Token.LBrace) {
-            const bg = this.braceGroup();
-            return { type: "For", pos, end: bg.end, name, wordlist, body: bg.body };
-        }
-        if (!this.accept(Token.Do, LexContext.CommandStart))
-            this.error("expected 'do'", this.tok.getPos());
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error("maximum for nesting depth exceeded", pos);
-            const closeEnd = this.tok.skipCompoundBody(Token.Done);
-            if (closeEnd < 0)
-                this.error("expected 'done' to close 'for'", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return { type: "For", pos, end, name, wordlist, body: this.makeCompoundList([]) };
-        }
-        this.syntaxDepth++;
-        const body = this.list();
-        this.syntaxDepth--;
-        this.skipSemi();
-        const closeEnd = this.acceptEnd(Token.Done, LexContext.CommandStart);
-        if (closeEnd < 0)
-            this.error("expected 'done' to close 'for'", this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        return { type: "For", pos, end, name, wordlist, body: this.makeCompoundList(body) };
-    }
-    // C-style for: (( expr; expr; expr )) [;|NL] do list done | { list }
-    cStyleFor(pos) {
-        const [initStr, testStr, updateStr, initPos, testPos, updatePos] = this.tok.readCStyleForExprs();
-        if (this.tok.peek(LexContext.CommandStart).token === Token.Semi)
-            this.tok.next(LexContext.CommandStart);
-        this.skipNewlines(LexContext.CommandStart);
-        if (this.tok.peek(LexContext.CommandStart).token === Token.LBrace) {
-            const bg = this.braceGroup();
-            return new ArithmeticForImpl(pos, bg.end, bg.body, initStr, testStr, updateStr, initPos, testPos, updatePos, this.source, this.depth);
-        }
-        if (!this.accept(Token.Do, LexContext.CommandStart))
-            this.error("expected 'do'", this.tok.getPos());
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error("maximum for nesting depth exceeded", pos);
-            const closeEnd = this.tok.skipCompoundBody(Token.Done);
-            if (closeEnd < 0)
-                this.error("expected 'done' to close 'for'", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return new ArithmeticForImpl(pos, end, this.makeCompoundList([]), initStr, testStr, updateStr, initPos, testPos, updatePos, this.source, this.depth);
-        }
-        this.syntaxDepth++;
-        const body = this.list();
-        this.syntaxDepth--;
-        const closeEnd = this.acceptEnd(Token.Done, LexContext.CommandStart);
-        if (closeEnd < 0)
-            this.error("expected 'done' to close 'for'", this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        return new ArithmeticForImpl(pos, end, this.makeCompoundList(body), initStr, testStr, updateStr, initPos, testPos, updatePos, this.source, this.depth);
-    }
-    whileClause() {
-        return this.whileOrUntil("while");
-    }
-    untilClause() {
-        return this.whileOrUntil("until");
-    }
-    whileOrUntil(kind) {
-        const pos = this.tok.next(LexContext.CommandStart).pos;
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error(`maximum ${kind} nesting depth exceeded`, pos);
-            const closeEnd = this.tok.skipCompoundBody(Token.Done);
-            if (closeEnd < 0)
-                this.error(`expected 'done' to close '${kind}'`, this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return {
-                type: "While",
-                pos,
-                end,
-                kind,
-                clause: this.makeCompoundList([]),
-                body: this.makeCompoundList([]),
-            };
-        }
-        this.syntaxDepth++;
-        const clause = this.makeCompoundList(this.list());
-        this.skipSemi();
-        if (!this.accept(Token.Do, LexContext.CommandStart))
-            this.error("expected 'do'", this.tok.getPos());
-        const body = this.list();
-        this.skipSemi();
-        const closeEnd = this.acceptEnd(Token.Done, LexContext.CommandStart);
-        if (closeEnd < 0)
-            this.error(`expected 'done' to close '${kind}'`, this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        this.syntaxDepth--;
-        return { type: "While", pos, end, kind, clause, body: this.makeCompoundList(body) };
-    }
-    // case_clause := CASE word IN (pattern) list (;; | ;& | ;;&) ... ESAC
-    caseClause() {
-        const pos = this.tok.next(LexContext.CommandStart).pos;
-        const word = this.readWord(LexContext.Normal);
-        this.skipNewlines(LexContext.CommandStart);
-        if (!this.accept(Token.In, LexContext.CommandStart))
-            this.error("expected 'in' after 'case' word", this.tok.getPos());
-        this.skipNewlines(LexContext.CommandStart);
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error("maximum case nesting depth exceeded", pos);
-            const closeEnd = this.tok.skipCompoundBody(Token.Esac);
-            if (closeEnd < 0)
-                this.error("expected 'esac' to close 'case'", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return { type: "Case", pos, end, word, items: [] };
-        }
-        this.syntaxDepth++;
-        const items = [];
-        let t = this.tok.peek(LexContext.CommandStart).token;
-        while (t !== Token.Esac && t !== Token.EOF) {
-            const itemPos = this.tok.peek(LexContext.Normal).pos;
-            this.accept(Token.LParen, LexContext.Normal);
-            const pattern = [];
-            t = this.tok.peek(LexContext.Normal).token;
-            while (t !== Token.RParen && t !== Token.EOF) {
-                if (t !== Token.Pipe)
-                    pattern.push(this.toWord(this.tok.next(LexContext.Normal)));
-                else
-                    this.tok.next(LexContext.Normal);
-                t = this.tok.peek(LexContext.Normal).token;
-            }
-            const rparenEnd = this.acceptEnd(Token.RParen, LexContext.Normal);
-            const cmds = this.list();
-            // An empty body belongs where commands would start, not wherever the lexer stopped.
-            const bodyPos = rparenEnd >= 0 ? rparenEnd : pattern.length > 0 ? pattern[pattern.length - 1].end : itemPos;
-            const itemEnd = cmds.length > 0 ? cmds[cmds.length - 1].end : bodyPos;
-            const item = {
-                type: "CaseItem",
-                pos: itemPos,
-                end: itemEnd,
-                pattern,
-                body: cmds.length > 0
-                    ? this.makeCompoundList(cmds)
-                    : { type: "CompoundList", pos: bodyPos, end: bodyPos, commands: [] },
-                terminator: undefined,
-            };
-            t = this.tok.peek(LexContext.CommandStart).token;
-            if (t === Token.DoubleSemi || t === Token.SemiAmp || t === Token.DoubleSemiAmp) {
-                const termTok = this.tok.next(LexContext.CommandStart);
-                item.terminator = CASE_TERMINATORS[termTok.token];
-                item.end = termTok.end;
-            }
-            items.push(item);
-            this.skipNewlines(LexContext.CommandStart);
-            t = this.tok.peek(LexContext.CommandStart).token;
-        }
-        const closeEnd = this.acceptEnd(Token.Esac, LexContext.CommandStart);
-        if (closeEnd < 0)
-            this.error("expected 'esac' to close 'case'", this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        this.syntaxDepth--;
-        return { type: "Case", pos, end, word, items };
-    }
-    // select_clause := SELECT word [IN word* (';'|NL)] DO list DONE
-    selectClause() {
-        const pos = this.tok.next(LexContext.CommandStart).pos;
-        const name = this.readWord(LexContext.Normal);
-        let wordlist;
-        this.skipNewlines(LexContext.CommandStart);
-        if (this.tok.peek(LexContext.CommandStart).token === Token.In) {
-            this.tok.next(LexContext.CommandStart);
-            wordlist = [];
-            while (this.tok.peek(LexContext.Normal).token === Token.Word) {
-                wordlist.push(this.readWord(LexContext.Normal));
-            }
-        }
-        this.skipSemi();
-        this.skipNewlines(LexContext.CommandStart);
-        if (this.tok.peek(LexContext.CommandStart).token === Token.LBrace) {
-            const bg = this.braceGroup();
-            return { type: "Select", pos, end: bg.end, name, wordlist, body: bg.body };
-        }
-        if (!this.accept(Token.Do, LexContext.CommandStart))
-            this.error("expected 'do'", this.tok.getPos());
-        if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-            this.error("maximum select nesting depth exceeded", pos);
-            const closeEnd = this.tok.skipCompoundBody(Token.Done);
-            if (closeEnd < 0)
-                this.error("expected 'done' to close 'select'", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : pos;
-            return { type: "Select", pos, end, name, wordlist, body: this.makeCompoundList([]) };
-        }
-        this.syntaxDepth++;
-        const body = this.list();
-        this.syntaxDepth--;
-        this.skipSemi();
-        const closeEnd = this.acceptEnd(Token.Done, LexContext.CommandStart);
-        if (closeEnd < 0)
-            this.error("expected 'done' to close 'select'", this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        return { type: "Select", pos, end, name, wordlist, body: this.makeCompoundList(body) };
-    }
-    // test_command := [[ test_expr ]]
-    testCommand() {
-        const pos = this.tok.next(LexContext.CommandStart).pos; // consume [[
-        const expr = this.parseTestOr();
-        const closeEnd = this.acceptEnd(Token.DblRBracket, LexContext.TestMode);
-        if (closeEnd < 0)
-            this.error("expected ']]' to close '[['", this.tok.getPos());
-        const end = closeEnd >= 0 ? closeEnd : pos;
-        return { type: "TestCommand", pos, end, expression: expr };
-    }
-    // test_or := test_and ('||' test_and)*
-    parseTestOr() {
-        let left = this.parseTestAnd();
-        while (this.tok.peek(LexContext.TestMode).token === Token.Or) {
-            this.tok.next(LexContext.TestMode);
-            const right = this.parseTestAnd();
-            left = {
-                type: "TestLogical",
-                pos: left.pos,
-                end: right.end,
-                operator: "||",
-                left,
-                right,
-            };
-        }
-        return left;
-    }
-    // test_and := test_not ('&&' test_not)*
-    parseTestAnd() {
-        let left = this.parseTestNot();
-        while (this.tok.peek(LexContext.TestMode).token === Token.And) {
-            this.tok.next(LexContext.TestMode);
-            const right = this.parseTestNot();
-            left = {
-                type: "TestLogical",
-                pos: left.pos,
-                end: right.end,
-                operator: "&&",
-                left,
-                right,
-            };
-        }
-        return left;
-    }
-    // test_not := '!' test_not | test_primary
-    parseTestNot() {
-        let t = this.tok.peek(LexContext.TestMode);
-        if (!isTestNegation(t))
-            return this.parseTestPrimary();
-        const firstPos = this.tok.next(LexContext.TestMode).pos;
-        t = this.tok.peek(LexContext.TestMode);
-        if (!isTestNegation(t)) {
-            const operand = this.parseTestPrimary();
-            return { type: "TestNot", pos: firstPos, end: operand.end, operand };
-        }
-        const positions = [firstPos];
-        while (isTestNegation(t)) {
-            positions.push(this.tok.next(LexContext.TestMode).pos);
-            t = this.tok.peek(LexContext.TestMode);
-        }
-        let expression = this.parseTestPrimary();
-        for (let i = positions.length - 1; i >= 0; i--) {
-            expression = {
-                type: "TestNot",
-                pos: positions[i],
-                end: expression.end,
-                operand: expression,
-            };
-        }
-        return expression;
-    }
-    // test_primary := '(' test_or ')' | unary_op word | word binary_op word | word
-    parseTestPrimary() {
-        // Grouped: ( expr )
-        if (this.tok.peek(LexContext.TestMode).token === Token.LParen) {
-            const openPos = this.tok.next(LexContext.TestMode).pos;
-            if (this.syntaxDepth === MAX_SYNTAX_NESTING) {
-                this.error("maximum test group nesting depth exceeded", openPos);
-                const closeEnd = this.tok.skipTestGroup();
-                if (closeEnd < 0)
-                    this.error("expected ')' to close test group", this.tok.getPos());
-                const end = closeEnd >= 0 ? closeEnd : openPos;
-                const operand = new WordImpl("", openPos, openPos, this.source, undefined, this.depth);
-                const expression = {
-                    type: "TestUnary",
-                    pos: openPos,
-                    end: openPos,
-                    operator: "-n",
-                    operand,
-                };
-                return { type: "TestGroup", pos: openPos, end, expression };
-            }
-            this.syntaxDepth++;
-            const expr = this.parseTestOr();
-            this.syntaxDepth--;
-            const closeEnd = this.acceptEnd(Token.RParen, LexContext.TestMode);
-            if (closeEnd < 0)
-                this.error("expected ')' to close test group", this.tok.getPos());
-            const end = closeEnd >= 0 ? closeEnd : openPos;
-            return { type: "TestGroup", pos: openPos, end, expression: expr };
-        }
-        const first = this.tok.next(LexContext.TestMode);
-        const val = first.value;
-        const firstPos = first.pos;
-        const firstEnd = first.end;
-        // Unary test: -op word, recognized only as written. Bash rejects the operator without an
-        // operand, so keep the operator and report the missing word instead of demoting it to a string.
-        if (first.keywordEligible && UNARY_TEST_OPS[val] === 1) {
-            if (this.tok.peek(LexContext.TestMode).token === Token.Word) {
-                const operand = this.readWord(LexContext.TestMode);
-                return {
-                    type: "TestUnary",
-                    pos: firstPos,
-                    end: operand.end,
-                    operator: val,
-                    operand,
-                };
-            }
-            this.error("expected operand after unary test operator", firstEnd);
-            const operand = new WordImpl("", firstEnd, firstEnd, this.source, undefined, this.depth);
-            return { type: "TestUnary", pos: firstPos, end: firstEnd, operator: val, operand };
-        }
-        // Check for binary op
-        const nt = this.tok.peek(LexContext.TestMode);
-        if (nt.token === Token.Word && nt.keywordEligible && BINARY_TEST_OPS[nt.value] === 1) {
-            const op = this.tok.next(LexContext.TestMode).value;
-            let right;
-            if (op === "=~") {
-                const token = this.tok.readTestRegexWord();
-                right = new WordImpl(this.source.slice(token.pos, token.end), token.pos, token.end, this.source, computeEmbeddedWordParts, this.depth);
-            }
-            else {
-                right = this.readWord(LexContext.TestMode);
-            }
-            const left = this.toWordFromPosEnd(first, firstPos, firstEnd);
-            return {
-                type: "TestBinary",
-                pos: firstPos,
-                end: right.end,
-                operator: op,
-                left,
-                right,
-            };
-        }
-        // Standalone word (implicit -n test)
-        const w = this.toWordFromPosEnd(first, firstPos, firstEnd);
-        return { type: "TestUnary", pos: firstPos, end: w.end, operator: "-n", operand: w };
-    }
-    // function_def with 'function' keyword
-    functionDef() {
-        const pos = this.tok.next(LexContext.CommandStart).pos;
-        const name = this.readWord(LexContext.Normal);
-        let body;
-        if (this.tok.peek(LexContext.CommandStart).token === Token.LParen) {
-            const openPos = this.tok.next(LexContext.CommandStart).pos;
-            // `(` is the optional empty parameter list only when `)` follows immediately;
-            // anything else opens a subshell body, as in `f() ( ... )`.
-            if (this.tok.peek(LexContext.CommandStart).token === Token.RParen) {
-                this.tok.next(LexContext.CommandStart);
-                this.skipNewlines(LexContext.CommandStart);
-                body = this.commandAsBody();
-            }
-            else {
-                body = this.withRedirects(this.subshellBody(openPos));
-            }
-        }
-        else {
-            this.skipNewlines(LexContext.CommandStart);
-            body = this.commandAsBody();
-        }
-        return { type: "Function", pos, end: body.end, name, body };
-    }
-    // simple_command or function_def (word '(' ')' body)
-    simpleCommandOrFunction() {
-        const prefix = [];
-        const cmdPos = this.tok.peek(LexContext.CommandStart).pos;
-        let lastEnd = cmdPos;
-        // Assignments and redirects interleave freely; after the first element CommandPrefix
-        // keeps the following command name from being read as a reserved word.
-        let ctx = LexContext.CommandStart;
-        for (;;) {
-            const t = this.tok.peek(ctx).token;
-            if (t === Token.Assignment) {
-                const assignment = this.tok.next(ctx);
-                lastEnd = assignment.end;
-                prefix.push(this.parseAssignment(assignment));
-            }
-            else if (t === Token.Redirect) {
-                const redirect = this.readRedirect(ctx);
-                prefix.push(redirect);
-                lastEnd = redirect.end;
-            }
-            else {
-                break;
-            }
-            ctx = LexContext.CommandPrefix;
-        }
-        if (this.tok.peek(LexContext.Normal).token !== Token.Word) {
-            return new CommandImpl(cmdPos, lastEnd, undefined, prefix, []);
-        }
-        const nameToken = this.tok.next(LexContext.Normal);
-        const declaration = nameToken.keywordEligible && isDeclarationCommand(nameToken.value);
-        const name = this.toWord(nameToken);
-        ctx = declaration ? LexContext.Declaration : LexContext.Normal;
-        lastEnd = name.end;
-        // Check for function definition: word '(' ')' body
-        if (this.tok.peek(ctx).token === Token.LParen) {
-            this.tok.next(LexContext.Normal);
-            if (this.tok.peek(LexContext.Normal).token === Token.RParen) {
-                this.tok.next(LexContext.Normal);
-                this.skipNewlines(LexContext.CommandStart);
-                const body = this.commandAsBody();
-                return {
-                    type: "Function",
-                    pos: name.pos,
-                    end: body.end,
-                    name,
-                    body,
-                };
-            }
-        }
-        const suffix = [];
-        // Collect suffix words and redirects
-        for (;;) {
-            const st = this.tok.peek(ctx).token;
-            if (st === Token.Word || st === Token.Assignment) {
-                const token = this.tok.next(ctx);
-                const w = st === Token.Assignment ? this.parseAssignment(token) : this.toWord(token);
-                suffix.push(w);
-                lastEnd = w.end;
-            }
-            else if (st === Token.Redirect) {
-                const redirect = this.readRedirect(ctx);
-                suffix.push(redirect);
-                lastEnd = redirect.end;
-            }
-            else {
-                break;
-            }
-        }
-        return new CommandImpl(cmdPos, lastEnd, name, prefix, suffix);
-    }
-    readRedirect(ctx) {
-        const t = this.tok.next(ctx);
-        const tPos = t.pos;
-        const tEnd = t.end;
-        const descriptor = t.fileDescriptor !== undefined
-            ? { type: "FileDescriptor", pos: tPos, end: t.descriptorEnd, value: t.fileDescriptor }
-            : t.variableName !== undefined
-                ? { type: "FileDescriptorVariable", pos: tPos, end: t.descriptorEnd, name: t.variableName }
-                : undefined;
-        const hasTarget = t.targetEnd > t.targetPos;
-        if (!hasTarget)
-            this.error("expected redirect target", t.targetPos);
-        if (t.value === "<<" || t.value === "<<-") {
-            const r = {
-                type: "HereDoc",
-                pos: tPos,
-                end: tEnd,
-                operator: t.value,
-                descriptor,
-                delimiter: hasTarget
-                    ? {
-                        type: "HereDocDelimiter",
-                        pos: t.targetPos,
-                        end: t.targetEnd,
-                        text: this.source.slice(t.targetPos, t.targetEnd),
-                        value: t.content ?? "",
-                        quoted: t.delimiterQuoted,
-                    }
-                    : undefined,
-                body: new HereDocBodyImpl(this.source, tEnd, t.delimiterQuoted, this.depth),
-                closing: undefined,
-            };
-            if (hasTarget)
-                this.tok.registerHereDocTarget(r);
-            return r;
-        }
-        const target = hasTarget
-            ? new WordImpl(this.source.slice(t.targetPos, t.targetEnd), t.targetPos, t.targetEnd, this.source, undefined, this.depth)
-            : undefined;
-        return t.value === "<<<"
-            ? { type: "HereString", pos: tPos, end: tEnd, operator: "<<<", descriptor, target }
-            : { type: "Redirect", pos: tPos, end: tEnd, operator: REDIRECT_OPS[t.value] ?? ">", descriptor, target };
-    }
-    commandAsBody() {
-        const cmd = this.command();
-        if (cmd && cmd.type !== "Command" && cmd.type !== "Function" && cmd.type !== "Coproc")
-            return cmd;
-        this.error("expected compound command as function body", cmd?.pos ?? this.tok.getPos());
-        return this.makeCompoundList(cmd ? [this.makeStatement(cmd)] : []);
-    }
-    readWord(ctx) {
-        return this.toWord(this.tok.next(ctx));
-    }
-    toWord(tok) {
-        const text = tok.raw ? tok.value : this.source.slice(tok.pos, tok.end);
-        // Raw keyword-eligible words have no quotes or expansions to resolve.
-        const source = tok.raw && tok.keywordEligible ? undefined : this.source;
-        return new WordImpl(text, tok.pos, tok.end, source, undefined, this.depth);
-    }
-    toWordFromPosEnd(tok, pos, end) {
-        if (tok.pos === pos && tok.end === end)
-            return this.toWord(tok);
-        return new WordImpl(this.source.slice(pos, end), pos, end, this.source, undefined, this.depth);
-    }
-    parseAssignment(token) {
-        const text = token.raw ? token.value : this.source.slice(token.pos, token.end);
-        return new AssignmentImpl(text, token.pos, token.end, this.source, token.assignmentOperatorPos, this.depth);
-    }
-    makeCompoundList(commands) {
-        const p = this.tok.getPos();
-        const pos = commands.length > 0 ? commands[0].pos : p;
-        const end = commands.length > 0 ? commands[commands.length - 1].end : p;
-        return { type: "CompoundList", pos, end, commands };
-    }
-}