@ykdz/template 0.0.36 → 0.0.38

package/node_modules/unbash/dist/lexer.js

@@ -0,0 +1,3930 @@
+import { decodeAnsiCQuoted } from "./ansi-c.js";
+import { parseArithmeticExpression } from "./arithmetic.js";
+import { WordImpl } from "./word.js";
+import { CH_TAB, CH_NL, CH_SPACE, CH_BANG, CH_DQUOTE, CH_HASH, CH_DOLLAR, CH_PERCENT, CH_AMP, CH_SQUOTE, CH_LPAREN, CH_RPAREN, CH_STAR, CH_PLUS, CH_COMMA, CH_DASH, CH_SLASH, CH_0, CH_9, CH_COLON, CH_SEMI, CH_LT, CH_EQ, CH_GT, CH_QUESTION, CH_AT, CH_A, CH_Z, CH_LBRACKET, CH_BACKSLASH, CH_RBRACKET, CH_CARET, CH_UNDERSCORE, CH_BACKTICK, CH_a, CH_z, CH_LBRACE, CH_PIPE, CH_RBRACE, } from "./chars.js";
+// Shared nesting budget for compound syntax and for structure materialized on demand
+// (sub-field words, nested substitution scripts). 256 nested levels stay lossless; past
+// that the lexer stops descending instead of overflowing the stack: deeper sub-fields
+// keep their raw text without parts, and substitution scripts stay unresolved past one
+// boundary script flagged with "maximum substitution nesting depth exceeded". The
+// iterative scanners additionally report the depth error where their counters can see
+// it (nested `${`, `$((`, and `$(`); cut-offs those counters cannot see (e.g. chains
+// interleaved with double quotes) degrade to plain text without an error.
+export const MAX_SYNTAX_NESTING = 256;
+export const Token = {
+    Word: 0,
+    Assignment: 1,
+    Semi: 2,
+    Newline: 3,
+    Pipe: 4,
+    And: 5,
+    Or: 6,
+    Amp: 7,
+    LParen: 8,
+    RParen: 9,
+    LBrace: 10,
+    RBrace: 11,
+    Bang: 12,
+    If: 13,
+    Then: 14,
+    Else: 15,
+    Elif: 16,
+    Fi: 17,
+    Do: 18,
+    Done: 19,
+    For: 20,
+    While: 21,
+    Until: 22,
+    In: 23,
+    Case: 24,
+    Esac: 25,
+    Function: 26,
+    DoubleSemi: 27,
+    SemiAmp: 28,
+    DoubleSemiAmp: 29,
+    Select: 30,
+    DblLBracket: 31,
+    DblRBracket: 32,
+    EOF: 33,
+    ArithCmd: 34,
+    Coproc: 35,
+    Redirect: 36,
+};
+export class TokenValue {
+    token = Token.EOF;
+    // Materialized token value, or null for word tokens whose value has not been
+    // requested yet (computed from [pos, end) on demand via the owning lexer).
+    _value = "";
+    _owner;
+    pos = 0;
+    end = 0;
+    fileDescriptor = undefined;
+    variableName = undefined;
+    descriptorEnd = 0;
+    delimiterQuoted = false;
+    content = undefined;
+    targetPos = 0;
+    targetEnd = 0;
+    assignmentOperatorPos = -1;
+    // True when `value` is exactly the raw source span [pos, end) — lets consumers
+    // reuse the string instead of slicing the source again.
+    raw = false;
+    // True when a word contains no quoting, escaped characters, or expansions.
+    // Backslash-newline continuations preserve keyword eligibility.
+    keywordEligible = false;
+    constructor(owner = null) {
+        this._owner = owner;
+    }
+    get value() {
+        return (this._value ?? (this._value = this._owner === null ? "" : this._owner._tokenValue(this.pos, this.end, this.raw)));
+    }
+    set value(v) {
+        this._value = v;
+    }
+    reset() {
+        this.token = Token.EOF;
+        this._value = "";
+        this.pos = 0;
+        this.end = 0;
+        this.fileDescriptor = undefined;
+        this.variableName = undefined;
+        this.descriptorEnd = 0;
+        this.delimiterQuoted = false;
+        this.content = undefined;
+        this.targetPos = 0;
+        this.targetEnd = 0;
+        this.assignmentOperatorPos = -1;
+        this.raw = false;
+        this.keywordEligible = false;
+    }
+    copyFrom(other) {
+        this.token = other.token;
+        this._value = other._value;
+        this.pos = other.pos;
+        this.end = other.end;
+        this.fileDescriptor = other.fileDescriptor;
+        this.variableName = other.variableName;
+        this.descriptorEnd = other.descriptorEnd;
+        this.delimiterQuoted = other.delimiterQuoted;
+        this.content = other.content;
+        this.targetPos = other.targetPos;
+        this.targetEnd = other.targetEnd;
+        this.assignmentOperatorPos = other.assignmentOperatorPos;
+        this.raw = other.raw;
+        this.keywordEligible = other.keywordEligible;
+    }
+}
+const RESERVED_WORDS = new Map([
+    ["if", Token.If],
+    ["then", Token.Then],
+    ["else", Token.Else],
+    ["elif", Token.Elif],
+    ["fi", Token.Fi],
+    ["do", Token.Do],
+    ["done", Token.Done],
+    ["for", Token.For],
+    ["while", Token.While],
+    ["until", Token.Until],
+    ["in", Token.In],
+    ["case", Token.Case],
+    ["esac", Token.Esac],
+    ["function", Token.Function],
+    ["select", Token.Select],
+    ["coproc", Token.Coproc],
+    ["!", Token.Bang],
+    ["{", Token.LBrace],
+    ["}", Token.RBrace],
+]);
+// `name()` is a syntax error for these; `time`, `[[` and `]]` are matched positionally
+// rather than through RESERVED_WORDS, and a name spelled like an assignment reads as a prefix.
+export function requiresFunctionKeyword(name) {
+    return RESERVED_WORDS.has(name) || name === "time" || name === "[[" || name === "]]" || name.includes("=");
+}
+// Combined character type table — bit 0: metachar, bit 1: word-special
+const charType = new Uint8Array(128);
+charType[CH_PIPE] = 1;
+charType[CH_AMP] = 1;
+charType[CH_SEMI] = 1;
+charType[CH_LPAREN] = 1;
+charType[CH_RPAREN] = 1;
+charType[CH_LT] = 1;
+charType[CH_GT] = 1;
+charType[CH_SPACE] = 1;
+charType[CH_TAB] = 1;
+charType[CH_NL] = 1;
+charType[CH_BACKSLASH] = 2;
+charType[CH_SQUOTE] = 2;
+charType[CH_DQUOTE] = 2;
+charType[CH_DOLLAR] = 2;
+charType[CH_BACKTICK] = 2;
+charType[CH_LBRACE] = 2;
+export function skipLineContinuations(source, pos, end) {
+    while (pos + 1 < end && source.charCodeAt(pos) === CH_BACKSLASH && source.charCodeAt(pos + 1) === CH_NL)
+        pos += 2;
+    return pos;
+}
+const arithmeticWordDelimiter = new Uint8Array(128);
+for (const ch of [
+    CH_TAB,
+    CH_NL,
+    CH_SPACE,
+    CH_BANG,
+    CH_PERCENT,
+    CH_AMP,
+    CH_LPAREN,
+    CH_RPAREN,
+    CH_STAR,
+    CH_PLUS,
+    CH_COMMA,
+    CH_DASH,
+    CH_SLASH,
+    CH_COLON,
+    CH_LT,
+    CH_EQ,
+    CH_GT,
+    CH_QUESTION,
+    CH_CARET,
+    CH_PIPE,
+]) {
+    arithmeticWordDelimiter[ch] = 1;
+}
+export function hasEmbeddedWordStructure(source, start, end) {
+    for (let pos = start; pos < end; pos++) {
+        const ch = source.charCodeAt(pos);
+        if (ch === CH_BACKSLASH ||
+            ch === CH_SQUOTE ||
+            ch === CH_DQUOTE ||
+            ch === CH_DOLLAR ||
+            ch === CH_BACKTICK ||
+            ((ch === CH_LT || ch === CH_GT) && pos + 1 < end && source.charCodeAt(pos + 1) === CH_LPAREN)) {
+            return true;
+        }
+    }
+    return false;
+}
+function findUnnested(s, target, pairTernaries = false, findNestedEnd) {
+    let depth = 0;
+    let ternaryDepth = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c === CH_BACKSLASH) {
+            i++;
+            continue;
+        }
+        if (c === CH_LBRACE) {
+            depth++;
+            continue;
+        }
+        if (c === CH_RBRACE) {
+            if (depth > 0)
+                depth--;
+            continue;
+        }
+        if (c === CH_SQUOTE) {
+            i++;
+            while (i < s.length && s.charCodeAt(i) !== CH_SQUOTE)
+                i++;
+            continue;
+        }
+        if (c === CH_DQUOTE) {
+            i++;
+            while (i < s.length) {
+                const quoted = s.charCodeAt(i);
+                if (quoted === CH_DQUOTE)
+                    break;
+                if (quoted === CH_BACKSLASH) {
+                    i += 2;
+                    continue;
+                }
+                const nestedEnd = findNestedEnd?.(i, true) ?? i;
+                if (nestedEnd > i) {
+                    i = nestedEnd;
+                    continue;
+                }
+                i++;
+            }
+            continue;
+        }
+        const nestedEnd = findNestedEnd?.(i, false) ?? i;
+        if (nestedEnd > i) {
+            i = nestedEnd - 1;
+            continue;
+        }
+        if (pairTernaries && depth === 0) {
+            if (c === CH_QUESTION) {
+                ternaryDepth++;
+                continue;
+            }
+            if (c === CH_COLON && ternaryDepth > 0) {
+                ternaryDepth--;
+                continue;
+            }
+        }
+        if (c === target && depth === 0)
+            return i;
+    }
+    return -1;
+}
+// Lookup: identifier chars (a-z, A-Z, 0-9, _) — bit 0: start, bit 1: continue
+const isIdChar = new Uint8Array(128);
+for (let i = CH_a; i <= CH_z; i++)
+    isIdChar[i] = 3;
+for (let i = CH_A; i <= CH_Z; i++)
+    isIdChar[i] = 3;
+for (let i = CH_0; i <= CH_9; i++)
+    isIdChar[i] = 2;
+isIdChar[CH_UNDERSCORE] = 3;
+const extglobPrefix = new Uint8Array(128);
+extglobPrefix[CH_QUESTION] = 1;
+extglobPrefix[CH_AT] = 1;
+extglobPrefix[CH_STAR] = 1;
+extglobPrefix[CH_PLUS] = 1;
+extglobPrefix[CH_BANG] = 1;
+extglobPrefix[CH_EQ] = 1;
+const extglobOp = {
+    [CH_QUESTION]: "?",
+    [CH_AT]: "@",
+    [CH_STAR]: "*",
+    [CH_PLUS]: "+",
+    [CH_BANG]: "!",
+};
+function isDQChild(p) {
+    const t = p.type;
+    return (t === "Literal" ||
+        t === "SimpleExpansion" ||
+        t === "ParameterExpansion" ||
+        t === "CommandExpansion" ||
+        t === "ArithmeticExpansion");
+}
+function isAllDigitsRange(src, start, end) {
+    for (let i = start; i < end; i++) {
+        const c = src.charCodeAt(i);
+        if (c < CH_0 || c > CH_9)
+            return false;
+    }
+    return end > start;
+}
+const ASSIGNMENT_INVALID = -1;
+const ASSIGNMENT_NAME_START = 0;
+const ASSIGNMENT_NAME = 1;
+const ASSIGNMENT_AFTER_INDEX = 2;
+const ASSIGNMENT_AFTER_PLUS = 3;
+const ASSIGNMENT_INDEX_BASE = 4;
+function isMatchedAssignment(state) {
+    return state < ASSIGNMENT_INVALID;
+}
+function assignmentOperatorPos(state) {
+    return -state - 2;
+}
+function scanAssignmentPrefix(src, start, end, initialState) {
+    let state = initialState;
+    for (let i = start; i < end && state >= 0; i++) {
+        const c = src.charCodeAt(i);
+        if (state >= ASSIGNMENT_INDEX_BASE) {
+            if (c === CH_LBRACKET)
+                state++;
+            else if (c === CH_RBRACKET && --state === ASSIGNMENT_INDEX_BASE)
+                state = ASSIGNMENT_AFTER_INDEX;
+        }
+        else if (state === ASSIGNMENT_NAME_START) {
+            state = c < 128 && isIdChar[c] & 1 ? ASSIGNMENT_NAME : ASSIGNMENT_INVALID;
+        }
+        else if (state === ASSIGNMENT_NAME) {
+            if (c < 128 && isIdChar[c] & 2)
+                continue;
+            if (c === CH_LBRACKET)
+                state = ASSIGNMENT_INDEX_BASE + 1;
+            else if (c === CH_PLUS)
+                state = ASSIGNMENT_AFTER_PLUS;
+            else
+                state = c === CH_EQ ? -i - 2 : ASSIGNMENT_INVALID;
+        }
+        else if (state === ASSIGNMENT_AFTER_INDEX) {
+            if (c === CH_PLUS)
+                state = ASSIGNMENT_AFTER_PLUS;
+            else
+                state = c === CH_EQ ? -i - 2 : ASSIGNMENT_INVALID;
+        }
+        else {
+            state = c === CH_EQ ? -i - 2 : ASSIGNMENT_INVALID;
+        }
+    }
+    return state;
+}
+const NO_EXPANSIONS = [];
+function setToken(out, token, value, pos = 0, end = 0) {
+    out.token = token;
+    out._value = value;
+    out.pos = pos;
+    out.end = end;
+    out.fileDescriptor = undefined;
+    out.variableName = undefined;
+    out.descriptorEnd = 0;
+    out.delimiterQuoted = false;
+    out.content = undefined;
+    out.assignmentOperatorPos = -1;
+    out.raw = false;
+    out.keywordEligible = false;
+}
+// Word token over [pos, end) whose value materializes on first access.
+function setSpanToken(out, token, pos, end, raw) {
+    out.token = token;
+    out._value = null;
+    out.pos = pos;
+    out.end = end;
+    out.fileDescriptor = undefined;
+    out.variableName = undefined;
+    out.descriptorEnd = 0;
+    out.delimiterQuoted = false;
+    out.content = undefined;
+    out.assignmentOperatorPos = -1;
+    out.raw = raw;
+    out.keywordEligible = false;
+}
+// Positional reserved-word match over src[start, start+len) — no slice. Mirrors
+// RESERVED_WORDS; first-char dispatch plus length checks reject fast.
+function matchReservedWord(src, start, len) {
+    switch (src.charCodeAt(start)) {
+        case CH_BANG:
+            return len === 1 ? Token.Bang : undefined;
+        case CH_LBRACE:
+            return len === 1 ? Token.LBrace : undefined;
+        case CH_RBRACE:
+            return len === 1 ? Token.RBrace : undefined;
+        case 0x69 /* i */: {
+            if (len !== 2)
+                return undefined;
+            const c = src.charCodeAt(start + 1);
+            return c === 0x66 /* f */ ? Token.If : c === 0x6e /* n */ ? Token.In : undefined;
+        }
+        case 0x66 /* f */:
+            if (len === 2)
+                return src.charCodeAt(start + 1) === 0x69 /* i */ ? Token.Fi : undefined;
+            if (len === 3)
+                return src.startsWith("for", start) ? Token.For : undefined;
+            if (len === 8)
+                return src.startsWith("function", start) ? Token.Function : undefined;
+            return undefined;
+        case 0x74 /* t */:
+            return len === 4 && src.startsWith("then", start) ? Token.Then : undefined;
+        case 0x65 /* e */:
+            if (len !== 4)
+                return undefined;
+            if (src.startsWith("else", start))
+                return Token.Else;
+            if (src.startsWith("elif", start))
+                return Token.Elif;
+            if (src.startsWith("esac", start))
+                return Token.Esac;
+            return undefined;
+        case 0x64 /* d */:
+            if (len === 2)
+                return src.charCodeAt(start + 1) === 0x6f /* o */ ? Token.Do : undefined;
+            if (len === 4)
+                return src.startsWith("done", start) ? Token.Done : undefined;
+            return undefined;
+        case 0x63 /* c */:
+            if (len === 4)
+                return src.startsWith("case", start) ? Token.Case : undefined;
+            if (len === 6)
+                return src.startsWith("coproc", start) ? Token.Coproc : undefined;
+            return undefined;
+        case 0x77 /* w */:
+            return len === 5 && src.startsWith("while", start) ? Token.While : undefined;
+        case 0x75 /* u */:
+            return len === 5 && src.startsWith("until", start) ? Token.Until : undefined;
+        case 0x73 /* s */:
+            return len === 6 && src.startsWith("select", start) ? Token.Select : undefined;
+        default:
+            return undefined;
+    }
+}
+export const LexContext = {
+    Normal: 0,
+    CommandStart: 1,
+    TestMode: 2,
+    // After a prefix element: assignments still recognized, reserved words not.
+    CommandPrefix: 3,
+    // Assignment arguments retain ordinary word boundaries inside subscripts.
+    Declaration: 4,
+    ArrayElement: 5,
+};
+function scanBraceExpansion(src, pos, len) {
+    const nextCh = pos + 1 < len ? src.charCodeAt(pos + 1) : 0;
+    if (nextCh <= CH_SPACE || nextCh === CH_RBRACE)
+        return -1;
+    let depth = 1;
+    let hasSep = false;
+    let scanPos = pos + 1;
+    while (scanPos < len && depth > 0) {
+        const bc = src.charCodeAt(scanPos);
+        if (bc === CH_LBRACE)
+            depth++;
+        else if (bc === CH_RBRACE) {
+            if (--depth === 0)
+                break;
+        }
+        else if (bc <= CH_SPACE || bc === CH_SEMI || bc === CH_PIPE || bc === CH_AMP)
+            return -1;
+        else if (depth === 1 &&
+            (bc === 0x2c /* , */ || (bc === 0x2e /* . */ && scanPos + 1 < len && src.charCodeAt(scanPos + 1) === 0x2e)))
+            hasSep = true;
+        if (bc === CH_BACKSLASH)
+            scanPos++;
+        scanPos++;
+    }
+    if (depth === 0 && hasSep)
+        return scanPos + 1;
+    return -1;
+}
+export class Lexer {
+    src;
+    srcEnd;
+    parenBoundary;
+    pos;
+    current;
+    nextState;
+    hasPeek;
+    pendingHereDocs;
+    collectedExpansions;
+    _errors = null;
+    _buildParts = false;
+    // Build processed text while scanning. Off on the normal token path (values
+    // materialize lazily); on for redirect targets, heredoc delimiters, arithmetic
+    // command bodies, and bounded value re-lexes. _buildParts implies it.
+    _buildValue = false;
+    // Nesting depth of the window being lexed (enclosing sub-fields plus substitution
+    // scripts), sharing the MAX_SYNTAX_NESTING budget across lazily created lexers.
+    _nestingDepth = 0;
+    // `start`/`end` bound the lexer to a window of `src` so substitution scripts can be
+    // parsed in place against the original source — every position is then absolute, with
+    // no slicing or re-basing. Defaults cover the whole string (the common top-level parse).
+    constructor(src, start = 0, end = src.length, parenBoundary = false) {
+        this.src = src;
+        this.srcEnd = end;
+        this.parenBoundary = parenBoundary;
+        this.pos = start;
+        this.current = new TokenValue(this);
+        this.nextState = new TokenValue(this);
+        this.hasPeek = false;
+        this.pendingHereDocs = null;
+        this.collectedExpansions = null;
+        if (start === 0 && src.charCodeAt(0) === CH_HASH && src.charCodeAt(1) === CH_BANG) {
+            const nl = src.indexOf("\n");
+            this.pos = nl === -1 ? this.srcEnd : nl + 1;
+        }
+    }
+    getSource() {
+        return this.src;
+    }
+    get errors() {
+        return this._errors ?? (this._errors = []);
+    }
+    getCollectedExpansions() {
+        return this.collectedExpansions ?? NO_EXPANSIONS;
+    }
+    // Collected expansions resolve after the enclosing scan unwinds, so each records the
+    // depth it was found at; resolveCollected charges that depth against the shared budget.
+    collect(part, inner, innerStart, parenBoundary = false) {
+        (this.collectedExpansions ?? (this.collectedExpansions = [])).push([
+            part,
+            this._nestingDepth,
+            inner,
+            innerStart,
+            parenBoundary,
+        ]);
+    }
+    getPos() {
+        return this.pos;
+    }
+    /** Materialize a word token's value: raw spans slice directly, others re-lex the span. */
+    _tokenValue(pos, end, raw) {
+        return raw ? this.src.slice(pos, end) : this.wordValueOf(pos, end);
+    }
+    // Re-lex [start, end) in value mode to produce the processed word text. Bounded
+    // to the span, so every expansion the original scan consumed closes within it.
+    // Errors were already reported by the original scan; suppress duplicates.
+    wordValueOf(start, end) {
+        const savedPos = this.pos;
+        const savedEnd = this.srcEnd;
+        const savedBuildValue = this._buildValue;
+        const savedUnbalanced = this._unbalanced;
+        const errorCount = this._errors === null ? 0 : this._errors.length;
+        this.pos = start;
+        this.srcEnd = end;
+        this._buildValue = true;
+        this.readWordText();
+        const value = this._wordText;
+        this.pos = savedPos;
+        this.srcEnd = savedEnd;
+        this._buildValue = savedBuildValue;
+        this._unbalanced = savedUnbalanced;
+        if (this._errors !== null)
+            this._errors.length = errorCount;
+        return value;
+    }
+    /** Find the closing bracket for a shell subscript, ignoring brackets inside nested shell syntax. */
+    findClosingBracket(start, end = this.srcEnd) {
+        return this.findClosingShellDelimiter(start, end, CH_RBRACKET);
+    }
+    /** Find the closing bracket of `$[ … ]`, which unlike a subscript does not recurse into `${ }`. */
+    findClosingArithmeticBracket(start, end = this.srcEnd) {
+        return this.findClosingShellDelimiter(start, end, CH_RBRACKET, false, false);
+    }
+    /** Find the closing brace for a parameter expansion, ignoring braces inside nested shell syntax. */
+    findClosingBrace(start, end = this.srcEnd) {
+        return this.findClosingShellDelimiter(start, end, CH_RBRACE);
+    }
+    /** Find the closing parenthesis for a shell substitution using the command-aware scanner. */
+    findClosingParenthesis(start, end = this.srcEnd) {
+        const savedPos = this.pos;
+        const savedEnd = this.srcEnd;
+        const savedUnbalanced = this._unbalanced;
+        this.pos = start;
+        this.srcEnd = Math.min(end, this.srcEnd);
+        this.extractBalanced();
+        const close = this._unbalanced ? -1 : this.pos - 1;
+        this.pos = savedPos;
+        this.srcEnd = savedEnd;
+        this._unbalanced = savedUnbalanced;
+        return close;
+    }
+    /** Find the end of one arithmetic expansion using the canonical lexer scanner. */
+    findArithmeticExpansionEnd(start, end = this.srcEnd) {
+        const scanner = new Lexer(this.src, start, end);
+        scanner.pos = start + 1;
+        scanner.scanArithmeticBody();
+        return scanner.pos;
+    }
+    /** Find the end of one shell-expanded arithmetic word using the canonical lexer scanners. */
+    findArithmeticWordEnd(start, end = this.srcEnd) {
+        const scanner = new Lexer(this.src, start, end);
+        scanner.pos = start;
+        return scanner.scanArithmeticWordEnd();
+    }
+    scanArithmeticWordEnd() {
+        while (this.pos < this.srcEnd) {
+            const ch = this.src.charCodeAt(this.pos);
+            if (ch === CH_DOLLAR) {
+                this.readDollar();
+                continue;
+            }
+            if (ch === CH_BACKTICK) {
+                this.readBacktickExpansion();
+                continue;
+            }
+            if (ch === CH_SQUOTE) {
+                this.pos++;
+                this.skipSQ();
+                continue;
+            }
+            if (ch === CH_DQUOTE) {
+                this.pos++;
+                this.skipDQ();
+                continue;
+            }
+            if (ch === CH_BACKSLASH) {
+                this.pos += 2;
+                continue;
+            }
+            if (ch === CH_LBRACKET) {
+                const close = this.findClosingBracket(this.pos + 1);
+                if (close !== -1) {
+                    this.pos = close + 1;
+                    continue;
+                }
+            }
+            if ((ch === CH_LT || ch === CH_GT) && this.src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+                this.pos += 2;
+                this.extractBalanced();
+                continue;
+            }
+            if (ch < 128 && arithmeticWordDelimiter[ch])
+                break;
+            this.pos++;
+        }
+        return this.pos;
+    }
+    // Only array assignment bodies take comments; extglob shares this scanner, and `#` is
+    // pattern data there.
+    findClosingShellDelimiter(start, end, closing, comments = false, braces = true) {
+        const savedPos = this.pos;
+        const savedEnd = this.srcEnd;
+        const savedUnbalanced = this._unbalanced;
+        this.srcEnd = Math.min(end, this.srcEnd);
+        const delimiters = [closing];
+        let pos = start;
+        let wordStart = true;
+        while (pos < this.srcEnd) {
+            const ch = this.src.charCodeAt(pos);
+            if (ch === CH_BACKSLASH) {
+                if (pos + 1 < this.srcEnd && this.src.charCodeAt(pos + 1) !== CH_NL)
+                    wordStart = false;
+                pos += 2;
+                continue;
+            }
+            if (ch === CH_HASH && comments && delimiters.length === 1 && wordStart) {
+                while (pos < this.srcEnd && this.src.charCodeAt(pos) !== CH_NL)
+                    pos++;
+                continue;
+            }
+            if (ch === CH_SQUOTE) {
+                this.pos = pos + 1;
+                this.skipSQ();
+                pos = this.pos;
+                wordStart = false;
+                continue;
+            }
+            if (ch === CH_DQUOTE) {
+                this.pos = pos + 1;
+                this.skipDQ();
+                pos = this.pos;
+                wordStart = false;
+                continue;
+            }
+            if (ch === CH_BACKTICK) {
+                pos++;
+                while (pos < this.srcEnd && this.src.charCodeAt(pos) !== CH_BACKTICK) {
+                    if (this.src.charCodeAt(pos) === CH_BACKSLASH)
+                        pos++;
+                    pos++;
+                }
+                if (pos < this.srcEnd)
+                    pos++;
+                wordStart = false;
+                continue;
+            }
+            if ((ch === CH_DOLLAR && pos + 1 < this.srcEnd && this.src.charCodeAt(pos + 1) === CH_LPAREN) ||
+                ((ch === CH_LT || ch === CH_GT) && pos + 1 < this.srcEnd && this.src.charCodeAt(pos + 1) === CH_LPAREN)) {
+                this.pos = pos + 2;
+                this.extractBalanced();
+                pos = this.pos;
+                wordStart = false;
+                continue;
+            }
+            const expected = delimiters[delimiters.length - 1];
+            if (ch === CH_DOLLAR && pos + 1 < this.srcEnd) {
+                const after = this.src.charCodeAt(pos + 1);
+                if (after === CH_DOLLAR) {
+                    pos += 2; // `$$` consumes its second `$`, so a `{` after it opens nothing
+                    wordStart = false;
+                    continue;
+                }
+                if (after === CH_LBRACE && braces) {
+                    delimiters.push(CH_RBRACE);
+                    pos += 2;
+                    wordStart = false;
+                    continue;
+                }
+            }
+            if (expected === CH_RBRACKET && ch === CH_LBRACKET) {
+                delimiters.push(CH_RBRACKET);
+            }
+            else if (expected === CH_RPAREN && ch === CH_LPAREN) {
+                delimiters.push(CH_RPAREN);
+            }
+            else if (ch === expected) {
+                delimiters.pop();
+                if (delimiters.length === 0) {
+                    this.pos = savedPos;
+                    this.srcEnd = savedEnd;
+                    this._unbalanced = savedUnbalanced;
+                    return pos;
+                }
+                wordStart = false;
+                pos++;
+                continue;
+            }
+            wordStart = ch < 128 && (charType[ch] & 1) !== 0;
+            pos++;
+        }
+        this.pos = savedPos;
+        this.srcEnd = savedEnd;
+        this._unbalanced = savedUnbalanced;
+        return -1;
+    }
+    skipSubshellBody() {
+        this.extractBalanced();
+        return this._unbalanced ? -1 : this.pos;
+    }
+    skipCompoundBody(closeToken) {
+        const frames = [
+            { close: closeToken, phase: closeToken === Token.Esac ? "case-pattern" : "commands" },
+        ];
+        let commandStart = true;
+        for (;;) {
+            const value = this.next(commandStart ? LexContext.CommandStart : LexContext.Normal);
+            const token = value.token;
+            if (token === Token.EOF)
+                return -1;
+            const last = frames.length - 1;
+            const frame = frames[last];
+            if (frame.phase === "function-name") {
+                if (token === Token.Newline)
+                    continue;
+                frame.phase = "function-body";
+                commandStart = true;
+                continue;
+            }
+            else if (frame.phase === "function-body") {
+                if (token === Token.Newline)
+                    continue;
+                frame.phase = "commands";
+                commandStart = true;
+                if (token === Token.LParen && this.peek(LexContext.Normal).token === Token.RParen) {
+                    this.next(LexContext.Normal);
+                    frame.phase = "function-body";
+                    continue;
+                }
+            }
+            else if (frame.phase === "coproc-command") {
+                if (token === Token.Newline)
+                    continue;
+                if (token === Token.Word) {
+                    frame.phase = "coproc-body";
+                    commandStart = true;
+                    continue;
+                }
+                frame.phase = "commands";
+                commandStart = true;
+            }
+            else if (frame.phase === "coproc-body") {
+                if (token === Token.Newline)
+                    continue;
+                frame.phase =
+                    token === Token.Word && value.keywordEligible && value.value === "time" ? "time-command" : "commands";
+                commandStart = true;
+                if (frame.phase === "time-command")
+                    continue;
+            }
+            else if (frame.phase === "time-command") {
+                if (token === Token.Word && value.keywordEligible && value.value === "-p") {
+                    frame.phase = "time-command-after-p";
+                    continue;
+                }
+                if (token === Token.Word && value.keywordEligible && value.value === "--") {
+                    frame.phase = "commands";
+                    continue;
+                }
+                frame.phase = "commands";
+                commandStart = true;
+            }
+            else if (frame.phase === "time-command-after-p") {
+                if (token === Token.Word && value.keywordEligible && value.value === "--") {
+                    frame.phase = "commands";
+                    continue;
+                }
+                frame.phase = "commands";
+                commandStart = true;
+            }
+            else if (frame.phase === "for-header") {
+                if (token === Token.ArithCmd || token === Token.Semi || token === Token.Newline) {
+                    commandStart = true;
+                    continue;
+                }
+                if (token === Token.Do || token === Token.LBrace) {
+                    frame.close = token === Token.Do ? Token.Done : Token.RBrace;
+                    frame.phase = "commands";
+                    commandStart = true;
+                    continue;
+                }
+            }
+            else if (frame.phase === "case-word") {
+                if (token === Token.Newline)
+                    continue;
+                frame.phase = "case-in";
+                commandStart = false;
+                continue;
+            }
+            else if (frame.phase === "case-in") {
+                if (token === Token.Newline) {
+                    commandStart = true;
+                    continue;
+                }
+                frame.phase = "case-pattern";
+                commandStart = true;
+                continue;
+            }
+            else if (frame.phase === "case-pattern") {
+                if (token === Token.Esac && commandStart) {
+                    frames.pop();
+                    if (frames.length === 0)
+                        return value.end;
+                    commandStart = false;
+                    continue;
+                }
+                if (token === Token.RParen) {
+                    frame.phase = "commands";
+                    commandStart = true;
+                }
+                else {
+                    commandStart = token === Token.Newline;
+                }
+                continue;
+            }
+            if (token === frame.close) {
+                frames.pop();
+                if (frames.length === 0)
+                    return value.end;
+                commandStart = false;
+                continue;
+            }
+            if (commandStart) {
+                switch (token) {
+                    case Token.LParen:
+                        frames.push({ close: Token.RParen, phase: "commands" });
+                        break;
+                    case Token.LBrace:
+                        frames.push({ close: Token.RBrace, phase: "commands" });
+                        break;
+                    case Token.If:
+                        frames.push({ close: Token.Fi, phase: "commands" });
+                        break;
+                    case Token.For:
+                        frames.push({ close: Token.Done, phase: "for-header" });
+                        break;
+                    case Token.While:
+                    case Token.Until:
+                    case Token.Select:
+                        frames.push({ close: Token.Done, phase: "commands" });
+                        break;
+                    case Token.Case:
+                        frames.push({ close: Token.Esac, phase: "case-word" });
+                        break;
+                    case Token.DblLBracket:
+                        if (!this.skipTestCommandBody())
+                            return -1;
+                        commandStart = false;
+                        continue;
+                    case Token.Assignment:
+                    case Token.Redirect:
+                    case Token.Bang:
+                    case Token.Then:
+                    case Token.Else:
+                    case Token.Elif:
+                    case Token.Do:
+                    case Token.In:
+                        break;
+                    case Token.Semi:
+                    case Token.Newline:
+                    case Token.Pipe:
+                    case Token.And:
+                    case Token.Or:
+                    case Token.Amp:
+                    case Token.DoubleSemi:
+                    case Token.SemiAmp:
+                    case Token.DoubleSemiAmp:
+                        break;
+                    case Token.Function:
+                        frame.phase = "function-name";
+                        break;
+                    case Token.Coproc:
+                        frame.phase = "coproc-command";
+                        break;
+                    default:
+                        if (token === Token.Word && value.keywordEligible && value.value === "time") {
+                            frame.phase = "time-command";
+                            commandStart = true;
+                        }
+                        else {
+                            commandStart = false;
+                        }
+                        continue;
+                }
+            }
+            switch (token) {
+                case Token.Semi:
+                case Token.Newline:
+                case Token.Pipe:
+                case Token.And:
+                case Token.Or:
+                case Token.Amp:
+                    commandStart = true;
+                    break;
+                case Token.DoubleSemi:
+                case Token.SemiAmp:
+                case Token.DoubleSemiAmp:
+                    if (frame.close === Token.Esac)
+                        frame.phase = "case-pattern";
+                    commandStart = true;
+                    break;
+                case Token.RParen:
+                    commandStart = true;
+                    break;
+            }
+        }
+    }
+    skipTestGroup() {
+        let depth = 1;
+        for (;;) {
+            const value = this.next(LexContext.TestMode);
+            if (value.token === Token.EOF)
+                return -1;
+            if (value.token === Token.DblRBracket) {
+                this.unshift(value);
+                return -1;
+            }
+            if (value.token === Token.LParen)
+                depth++;
+            else if (value.token === Token.RParen && --depth === 0)
+                return value.end;
+        }
+    }
+    skipTestCommandBody() {
+        for (;;) {
+            const token = this.next(LexContext.TestMode).token;
+            if (token === Token.DblRBracket)
+                return true;
+            if (token === Token.EOF)
+                return false;
+        }
+    }
+    /** Set position and scan a word, building parts. Used by computeWordParts. */
+    buildWordParts(startPos) {
+        this._buildParts = true;
+        this.pos = startPos;
+        // Handle process substitution words <(...) and >(...)
+        const ch = this.src.charCodeAt(startPos);
+        if ((ch === 0x3c /* < */ || ch === 0x3e) /* > */ &&
+            startPos + 1 < this.srcEnd &&
+            this.src.charCodeAt(startPos + 1) === 0x28 /* ( */) {
+            this.pos = startPos + 2;
+            const inner = this.extractBalanced();
+            if (this._unbalanced)
+                this.errors.push({ message: "unterminated process substitution", pos: startPos });
+            const text = this.src.slice(startPos, this.pos);
+            const part = {
+                type: "ProcessSubstitution",
+                pos: startPos,
+                end: this.pos,
+                text,
+                operator: ch === 0x3c ? "<" : ">",
+                script: undefined,
+            };
+            this.collect(part, inner, startPos + 2, !this._unbalanced);
+            // Continue reading any trailing word text (e.g., suffix after proc sub)
+            if (this.pos < this.srcEnd) {
+                this.readWordText();
+                if (this._wordParts) {
+                    this._wordParts.unshift(part);
+                }
+                else {
+                    this._wordParts = [part];
+                }
+            }
+            else {
+                this._wordParts = [part];
+            }
+        }
+        else {
+            this.readWordText();
+        }
+        return this._wordParts;
+    }
+    /** Scan a bounded word-like span without treating shell operators or whitespace as terminators. */
+    buildEmbeddedWordParts(startPos) {
+        this._buildParts = true;
+        this.pos = startPos;
+        this.readInnerWordText();
+        return this._wordParts;
+    }
+    buildArrayElementParts(startPos) {
+        const close = this.findClosingBracket(startPos + 1);
+        if (close === -1)
+            return this.buildWordParts(startPos);
+        this._buildParts = true;
+        const prefix = hasEmbeddedWordStructure(this.src, startPos, close + 1)
+            ? this.parseSubFieldWord(startPos, close + 1)
+            : undefined;
+        this.pos = close + 1;
+        this.readWordText();
+        const parts = this._wordParts;
+        const prefixParts = prefix?.parts;
+        if (prefixParts) {
+            if (parts)
+                return prefixParts.concat(parts);
+            if (this.pos > close + 1) {
+                prefixParts.push({
+                    type: "Literal",
+                    pos: close + 1,
+                    end: this.pos,
+                    text: this.src.slice(close + 1, this.pos),
+                    value: this._wordText,
+                });
+            }
+            return prefixParts;
+        }
+        if (parts) {
+            const text = this.src.slice(startPos, close + 1);
+            parts.unshift({ type: "Literal", pos: startPos, end: close + 1, text, value: prefix?.value ?? text });
+        }
+        return parts;
+    }
+    /** Scan a heredoc body for expansions, building parts. Spaces/newlines are literal. */
+    buildHereDocParts(bodyPos, bodyEnd) {
+        this._buildParts = true;
+        const src = this.src;
+        const parts = [];
+        let hasExpansion = false;
+        let litBuf = "";
+        let litStart = bodyPos;
+        let i = bodyPos;
+        const flushLit = () => {
+            if (i > litStart) {
+                parts.push({ type: "Literal", pos: litStart, end: i, value: litBuf, text: src.slice(litStart, i) });
+                litBuf = "";
+            }
+        };
+        while (i < bodyEnd) {
+            const ch = src.charCodeAt(i);
+            if (ch === 0x5c /* \\ */) {
+                // Backslash escape — in unquoted heredoc, \\$, \\`, \\\\ are special
+                if (i + 1 < bodyEnd) {
+                    const nc = src.charCodeAt(i + 1);
+                    if (nc === CH_NL) {
+                        i += 2;
+                        continue;
+                    }
+                    if (nc === 0x24 /* $ */ || nc === 0x60 /* ` */ || nc === 0x5c /* \\ */) {
+                        litBuf += String.fromCharCode(nc);
+                        i += 2;
+                        continue;
+                    }
+                }
+                litBuf += "\\";
+                i++;
+                continue;
+            }
+            if (ch === 0x24 /* $ */) {
+                flushLit();
+                litStart = i;
+                this.pos = i;
+                this.readDollar();
+                if (this._resultPart) {
+                    hasExpansion = true;
+                    parts.push(this._resultPart);
+                    litStart = this.pos;
+                }
+                else {
+                    litBuf += src.slice(i, this.pos);
+                }
+                i = this.pos;
+                continue;
+            }
+            if (ch === 0x60 /* ` */) {
+                flushLit();
+                litStart = i;
+                this.pos = i;
+                this.readBacktickExpansion();
+                if (this._resultPart) {
+                    hasExpansion = true;
+                    parts.push(this._resultPart);
+                    litStart = this.pos;
+                }
+                else {
+                    litBuf += src.slice(i, this.pos);
+                }
+                i = this.pos;
+                continue;
+            }
+            litBuf += src[i];
+            i++;
+        }
+        flushLit();
+        return hasExpansion ? parts : null;
+    }
+    registerHereDocTarget(target) {
+        if (this.pendingHereDocs === null)
+            return;
+        for (const hd of this.pendingHereDocs) {
+            if (!hd.target) {
+                hd.target = target;
+                return;
+            }
+        }
+    }
+    // Read the right-hand operand of =~ in [[ ]]. Bash ends the operand at
+    // depth-zero whitespace, `)`, `;`, `&`, `<`, or `>` (but `<(`/`>(` open a
+    // process substitution and `|` never delimits). An unquoted `(` opens a
+    // group that consumes everything — `]]`, newlines, and metacharacters
+    // included — until its matching `)`; inside a group only quotes stay opaque
+    // and expansion parens count naively, matching bash. Quotes and expansions
+    // at depth zero skip via the same readers normal words use, so their errors
+    // and spans stay identical. The token is the raw source span; value and
+    // parts resolve lazily like every other word.
+    readTestRegexWord() {
+        this.hasPeek = false;
+        this.skipSpacesAndTabs();
+        const src = this.src;
+        const len = this.srcEnd;
+        const start = this.pos;
+        let depth = 0;
+        while (this.pos < len) {
+            const ch = src.charCodeAt(this.pos);
+            if (ch === CH_LPAREN) {
+                depth++;
+                this.pos++;
+                continue;
+            }
+            if (ch === CH_BACKSLASH) {
+                this.pos += this.pos + 1 < len ? 2 : 1;
+                continue;
+            }
+            if (ch === CH_SQUOTE) {
+                const quotePos = this.pos++;
+                const ansiC = quotePos > start && src.charCodeAt(quotePos - 1) === CH_DOLLAR;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_SQUOTE) {
+                    if (ansiC && src.charCodeAt(this.pos) === CH_BACKSLASH && this.pos + 1 < len)
+                        this.pos++;
+                    this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+                else
+                    this.errors.push({
+                        message: ansiC ? "unterminated ANSI-C quote" : "unterminated single quote",
+                        pos: quotePos,
+                    });
+                continue;
+            }
+            if (ch === CH_DQUOTE) {
+                this.pos++;
+                this.readDoubleQuoted();
+                continue;
+            }
+            if (ch === CH_BACKTICK) {
+                this.readBacktickExpansion();
+                continue;
+            }
+            if (depth > 0) {
+                if (ch === CH_RPAREN)
+                    depth--;
+                this.pos++;
+                continue;
+            }
+            if (ch === CH_DOLLAR) {
+                this.readDollar();
+                continue;
+            }
+            if ((ch === CH_LT || ch === CH_GT) && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+                const subPos = this.pos;
+                this.pos += 2;
+                this.extractBalanced();
+                if (this._unbalanced)
+                    this.errors.push({ message: "unterminated process substitution", pos: subPos });
+                continue;
+            }
+            if (ch < 128 && charType[ch] & 1 && ch !== CH_PIPE)
+                break;
+            this.pos++;
+        }
+        setToken(this.current, Token.Word, src.slice(start, this.pos), start, this.pos);
+        return this.current;
+    }
+    // Read C-style for expressions: called after first '(' consumed by parser.
+    // Expects pos at second '('. Returns [init, test, update] raw text.
+    readCStyleForExprs() {
+        this.hasPeek = false; // discard any peeked token
+        const src = this.src;
+        const len = this.srcEnd;
+        // Skip spaces to second '('
+        while (this.pos < len && (src.charCodeAt(this.pos) === CH_SPACE || src.charCodeAt(this.pos) === CH_TAB))
+            this.pos++;
+        const openPos = this.pos;
+        if (this.pos < len && src.charCodeAt(this.pos) === CH_LPAREN)
+            this.pos++;
+        const starts = [this.pos, 0, 0];
+        const parts = ["", "", "", 0, 0, 0];
+        let partIdx = 0;
+        let depth = 1;
+        let partStart = this.pos;
+        let extra = false;
+        const setPart = (end) => {
+            const raw = src.slice(partStart, end);
+            parts[partIdx] = raw.trim();
+            parts[3 + partIdx] = starts[partIdx] + raw.length - raw.trimStart().length;
+        };
+        while (this.pos < len && depth > 0) {
+            const c = src.charCodeAt(this.pos);
+            if (c === CH_LPAREN) {
+                depth++;
+                this.pos++;
+            }
+            else if (c === CH_RPAREN) {
+                depth--;
+                if (depth === 0) {
+                    if (!extra)
+                        setPart(this.pos);
+                    if (partIdx < 2)
+                        this.errors.push({ message: "expected three arithmetic expressions in for header", pos: this.pos });
+                    this.pos++; // skip closing )
+                    // Skip the outer ) as well
+                    while (this.pos < len && (src.charCodeAt(this.pos) === CH_SPACE || src.charCodeAt(this.pos) === CH_TAB))
+                        this.pos++;
+                    if (this.pos < len && src.charCodeAt(this.pos) === CH_RPAREN)
+                        this.pos++;
+                    break;
+                }
+                this.pos++;
+            }
+            else if (c === CH_SEMI && depth === 1) {
+                // Bash requires exactly three expressions; keep the first three and report the rest.
+                if (partIdx === 2) {
+                    if (!extra) {
+                        setPart(this.pos);
+                        this.errors.push({ message: "expected three arithmetic expressions in for header", pos: this.pos });
+                    }
+                    extra = true;
+                    this.pos++;
+                    continue;
+                }
+                setPart(this.pos);
+                partIdx++;
+                this.pos++;
+                partStart = this.pos;
+                starts[partIdx] = partStart;
+            }
+            else if (c === CH_SQUOTE) {
+                this.pos++;
+                this.skipSQ();
+            }
+            else if (c === CH_DQUOTE) {
+                this.pos++;
+                this.skipDQ();
+            }
+            else {
+                this.pos++;
+            }
+        }
+        if (depth > 0) {
+            if (!extra)
+                setPart(this.pos);
+            this.errors.push({ message: "unterminated arithmetic for header", pos: openPos });
+        }
+        return parts;
+    }
+    peek(ctx = LexContext.Normal) {
+        if (!this.hasPeek) {
+            this.readNext(this.nextState, ctx);
+            this.hasPeek = true;
+        }
+        return this.nextState;
+    }
+    // Peek where the context depends on the token just consumed. peek() ignores its ctx once a
+    // token is cached, so the caller's context must only be derived when a read actually happens.
+    peekFollow(closers) {
+        if (!this.hasPeek) {
+            const ctx = closers[this.current.token] ? LexContext.CommandStart : LexContext.Normal;
+            this.readNext(this.nextState, ctx);
+            this.hasPeek = true;
+        }
+        return this.nextState;
+    }
+    next(ctx = LexContext.Normal) {
+        if (this.hasPeek) {
+            this.hasPeek = false;
+            const temp = this.current;
+            this.current = this.nextState;
+            this.nextState = temp;
+            return this.current;
+        }
+        this.readNext(this.current, ctx);
+        return this.current;
+    }
+    unshift(tok) {
+        this.nextState.copyFrom(tok);
+        this.hasPeek = true;
+    }
+    readNext(out, ctx) {
+        const src = this.src;
+        const len = this.srcEnd;
+        // Skip spaces and tabs (inlined for hot path)
+        let pos = this.pos;
+        while (pos < len) {
+            const ch = src.charCodeAt(pos);
+            if (ch === CH_SPACE || ch === CH_TAB) {
+                pos++;
+                continue;
+            }
+            if (ch === CH_BACKSLASH && pos + 1 < len && src.charCodeAt(pos + 1) === CH_NL) {
+                pos += 2;
+                continue;
+            }
+            // Inside [[ ]], newlines are whitespace
+            if (ch === CH_NL && ctx === LexContext.TestMode) {
+                pos++;
+                continue;
+            }
+            break;
+        }
+        this.pos = pos;
+        if (pos >= len) {
+            this.consumePendingHereDocs();
+            setToken(out, Token.EOF, "", pos, pos);
+            return;
+        }
+        const tokenStart = pos;
+        const ch = src.charCodeAt(pos);
+        if (ch === CH_HASH) {
+            // Skip comment
+            while (this.pos < len && src.charCodeAt(this.pos) !== CH_NL)
+                this.pos++;
+            this.readNext(out, ctx);
+            return;
+        }
+        if (ch === CH_NL) {
+            this.pos++;
+            this.consumePendingHereDocs();
+            setToken(out, Token.Newline, "\n", tokenStart, this.pos);
+            return;
+        }
+        // In test mode (inside [[ ]]), < and > are string comparison operators, not redirects —
+        // except for an adjacent '(', which still opens a process substitution
+        if (ctx === LexContext.TestMode &&
+            (ch === CH_LT || ch === CH_GT) &&
+            !(this.pos + 1 < this.srcEnd && src.charCodeAt(this.pos + 1) === CH_LPAREN)) {
+            this.pos++;
+            setToken(out, Token.Word, ch === CH_LT ? "<" : ">", tokenStart, this.pos);
+            out.keywordEligible = true; // written unquoted, so it is the comparison operator
+            return;
+        }
+        // Operators all start with a metachar; anything else is a word
+        if (ch < 128 && charType[ch] & 1 && this.tryReadOperator(out, ch, ctx, tokenStart))
+            return;
+        if (ch === CH_LBRACKET && ctx === LexContext.ArrayElement && this.readArrayElement(out, tokenStart))
+            return;
+        this.readWord(out, ctx, tokenStart);
+    }
+    tryReadOperator(out, ch, ctx, tokenStart) {
+        const src = this.src;
+        const pos = this.pos;
+        const next = pos + 1 < this.srcEnd ? src.charCodeAt(pos + 1) : 0;
+        switch (ch) {
+            case CH_SEMI:
+                if (next === CH_SEMI) {
+                    if (pos + 2 < this.srcEnd && src.charCodeAt(pos + 2) === CH_AMP) {
+                        this.pos += 3;
+                        setToken(out, Token.DoubleSemiAmp, ";;&", tokenStart, this.pos);
+                        return true;
+                    }
+                    this.pos += 2;
+                    setToken(out, Token.DoubleSemi, ";;", tokenStart, this.pos);
+                    return true;
+                }
+                if (next === CH_AMP) {
+                    this.pos += 2;
+                    setToken(out, Token.SemiAmp, ";&", tokenStart, this.pos);
+                    return true;
+                }
+                this.pos++;
+                setToken(out, Token.Semi, ";", tokenStart, this.pos);
+                return true;
+            case CH_PIPE:
+                if (next === CH_PIPE) {
+                    this.pos += 2;
+                    setToken(out, Token.Or, "||", tokenStart, this.pos);
+                    return true;
+                }
+                if (next === CH_AMP) {
+                    this.pos += 2;
+                    setToken(out, Token.Pipe, "|&", tokenStart, this.pos);
+                    return true;
+                } // |& → pipe (stderr merge)
+                this.pos++;
+                setToken(out, Token.Pipe, "|", tokenStart, this.pos);
+                return true;
+            case CH_AMP:
+                if (next === CH_AMP) {
+                    this.pos += 2;
+                    setToken(out, Token.And, "&&", tokenStart, this.pos);
+                    return true;
+                }
+                if (next === CH_GT) {
+                    // &> or &>> — redirect, not background
+                    this.pos += 2;
+                    const append = this.pos < this.srcEnd && src.charCodeAt(this.pos) === CH_GT;
+                    if (append)
+                        this.pos++;
+                    this.skipSpacesAndTabs();
+                    const targetPos = this.pos;
+                    if (this.pos < this.srcEnd && src.charCodeAt(this.pos) !== CH_NL && src.charCodeAt(this.pos) !== CH_HASH) {
+                        this.readRedirectTargetText();
+                    }
+                    this.redirectToken(out, append ? "&>>" : "&>", tokenStart, targetPos);
+                    return true;
+                }
+                this.pos++;
+                setToken(out, Token.Amp, "&", tokenStart, this.pos);
+                return true;
+            case CH_LPAREN:
+                if (ctx === LexContext.CommandStart && next === CH_LPAREN) {
+                    const savedErrors = this.errors.length;
+                    this.readArithmeticCommand(out, tokenStart);
+                    if (!this._notArithmetic)
+                        return true;
+                    this.errors.length = savedErrors;
+                    this.pos = tokenStart;
+                }
+                this.pos++;
+                setToken(out, Token.LParen, "(", tokenStart, this.pos);
+                return true;
+            case CH_RPAREN:
+                this.pos++;
+                setToken(out, Token.RParen, ")", tokenStart, this.pos);
+                return true;
+            case CH_LT:
+            case CH_GT:
+                return this.readRedirection(out, tokenStart);
+            default:
+                return false;
+        }
+    }
+    readRedirection(out, tokenStart) {
+        const src = this.src;
+        const ch = src.charCodeAt(this.pos);
+        let op = "";
+        if (ch === CH_LT) {
+            this.pos++;
+            const next = this.pos < this.srcEnd ? src.charCodeAt(this.pos) : 0;
+            if (next === CH_LT) {
+                this.pos++;
+                const third = this.pos < this.srcEnd ? src.charCodeAt(this.pos) : 0;
+                if (third === CH_LT) {
+                    // <<< herestring
+                    this.pos++;
+                    this.skipSpacesAndTabs();
+                    const targetPos = this.pos;
+                    if (this.pos < this.srcEnd && src.charCodeAt(this.pos) !== CH_NL && src.charCodeAt(this.pos) !== CH_HASH) {
+                        this.readRedirectTargetText();
+                    }
+                    this.redirectToken(out, "<<<", tokenStart, targetPos);
+                    return true;
+                }
+                const dash = third === CH_DASH;
+                if (dash)
+                    this.pos++;
+                this.skipSpacesAndTabs();
+                const targetPos = this.pos;
+                if (this.pos >= this.srcEnd || src.charCodeAt(this.pos) !== CH_HASH)
+                    this.readHereDocDelimiter();
+                const hasTarget = this.pos > targetPos;
+                if (hasTarget) {
+                    (this.pendingHereDocs ?? (this.pendingHereDocs = [])).push({
+                        delimiter: this._hereDelim,
+                        strip: dash,
+                        quoted: this._hereQuoted,
+                    });
+                }
+                setToken(out, Token.Redirect, dash ? "<<-" : "<<", tokenStart, this.pos);
+                out.content = hasTarget ? this._hereDelim : undefined;
+                out.delimiterQuoted = hasTarget && this._hereQuoted;
+                out.targetPos = targetPos;
+                out.targetEnd = hasTarget ? this.pos : targetPos;
+                return true;
+            }
+            if (next === CH_LPAREN) {
+                this.readProcessSubstitution(out, "<", tokenStart);
+                return true;
+            }
+            if (next === CH_GT) {
+                op = "<>";
+                this.pos++;
+            }
+            else if (next === CH_AMP) {
+                op = "<&";
+                this.pos++;
+            }
+            else {
+                op = "<";
+            }
+        }
+        else if (ch === CH_GT) {
+            this.pos++;
+            const next = this.pos < this.srcEnd ? src.charCodeAt(this.pos) : 0;
+            if (next === CH_LPAREN) {
+                this.readProcessSubstitution(out, ">", tokenStart);
+                return true;
+            }
+            if (next === CH_GT) {
+                op = ">>";
+                this.pos++;
+            }
+            else if (next === CH_AMP) {
+                op = ">&";
+                this.pos++;
+            }
+            else if (next === CH_PIPE) {
+                op = ">|";
+                this.pos++;
+            }
+            else {
+                op = ">";
+            }
+        }
+        this.skipSpacesAndTabs();
+        if (this.pos < this.srcEnd) {
+            const nc = src.charCodeAt(this.pos);
+            if ((nc === CH_LT || nc === CH_GT) && this.pos + 1 < this.srcEnd && src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+                const psStart = this.pos;
+                this.pos += 2;
+                this.extractBalanced();
+                if (this._unbalanced)
+                    this.errors.push({ message: "unterminated process substitution", pos: psStart });
+                const psText = src.slice(psStart, this.pos);
+                setToken(out, Token.Redirect, op, tokenStart, this.pos);
+                out.content = psText;
+                out.targetPos = psStart;
+                out.targetEnd = this.pos;
+                return true;
+            }
+            const targetPos = this.pos;
+            if (nc !== CH_NL && nc !== CH_HASH)
+                this.readRedirectTargetText();
+            this.redirectToken(out, op, tokenStart, targetPos);
+            return true;
+        }
+        this.redirectToken(out, op, tokenStart, this.pos);
+        return true;
+    }
+    // Redirect targets keep their processed text eagerly (it becomes the target
+    // word's content), so scan them in value mode.
+    readRedirectTargetText() {
+        const savedBuildValue = this._buildValue;
+        this._buildValue = true;
+        this.readWordText();
+        this._buildValue = savedBuildValue;
+    }
+    redirectToken(out, operator, tokenStart, targetPos) {
+        const hasTarget = this.pos > targetPos && (this._wordText.length > 0 || this._wordQuoted);
+        setToken(out, Token.Redirect, operator, tokenStart, this.pos);
+        out.content = hasTarget ? this._wordText : undefined;
+        out.targetPos = targetPos;
+        out.targetEnd = hasTarget ? this.pos : targetPos;
+    }
+    readProcessSubstitution(out, operator, tokenStart) {
+        this.pos++; // skip (
+        this.extractBalanced();
+        if (this._unbalanced)
+            this.errors.push({ message: "unterminated process substitution", pos: tokenStart });
+        const text = this.src.slice(tokenStart, this.pos);
+        setToken(out, Token.Word, text, tokenStart, this.pos);
+    }
+    // The delimiter is the word after quote removal: quote and escape segments may
+    // appear anywhere in the word, any of them makes the heredoc quoted, and inside
+    // double quotes a backslash is removed only before $ ` " \.
+    readHereDocDelimiter() {
+        const src = this.src;
+        const len = this.srcEnd;
+        const savedBuildValue = this._buildValue;
+        this._buildValue = true; // the delimiter is assembled from processed segments
+        let delimiter = "";
+        let quoted = false;
+        while (this.pos < len) {
+            const c = src.charCodeAt(this.pos);
+            if (c === CH_SQUOTE) {
+                quoted = true;
+                this.pos++;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_SQUOTE) {
+                    delimiter += src[this.pos];
+                    this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+            }
+            else if (c === CH_DQUOTE) {
+                quoted = true;
+                this.pos++;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_DQUOTE) {
+                    if (src.charCodeAt(this.pos) === CH_BACKSLASH && this.pos + 1 < len) {
+                        const next = src.charCodeAt(this.pos + 1);
+                        if (next === CH_NL) {
+                            this.pos += 2;
+                            continue;
+                        }
+                        if (next === CH_DOLLAR || next === CH_BACKTICK || next === CH_DQUOTE || next === CH_BACKSLASH)
+                            this.pos++;
+                    }
+                    delimiter += src[this.pos];
+                    this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+            }
+            else if (c === CH_BACKSLASH) {
+                if (this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_NL) {
+                    this.pos += 2;
+                    continue;
+                }
+                quoted = true;
+                this.pos++;
+                if (this.pos < len) {
+                    delimiter += src[this.pos];
+                    this.pos++;
+                }
+                else {
+                    delimiter += "\\"; // trailing backslash escapes nothing and stays as itself
+                }
+            }
+            else if (c === CH_BACKTICK) {
+                const btStart = this.pos;
+                this.pos++;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+                    if (src.charCodeAt(this.pos) === CH_BACKSLASH)
+                        this.pos++;
+                    this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+                delimiter += src.slice(btStart, this.pos);
+            }
+            else if (c === CH_DOLLAR) {
+                const next = this.pos + 1 < len ? src.charCodeAt(this.pos + 1) : 0;
+                if (next === CH_SQUOTE || next === CH_DQUOTE)
+                    quoted = true;
+                this.readDollar();
+                delimiter += this._resultText;
+            }
+            else if (c < 128 && charType[c] & 1) {
+                break;
+            }
+            else {
+                delimiter += src[this.pos];
+                this.pos++;
+            }
+        }
+        this._buildValue = savedBuildValue;
+        this._hereDelim = delimiter;
+        this._hereQuoted = quoted;
+    }
+    consumePendingHereDocs() {
+        const pending = this.pendingHereDocs;
+        if (pending === null || pending.length === 0)
+            return;
+        for (const hd of pending) {
+            const bodyPos = this.pos;
+            const bodyEnd = this.skipHereDocBody(hd.delimiter, hd.strip, this.parenBoundary, hd.quoted);
+            if (hd.target) {
+                hd.target.body.pos = bodyPos;
+                hd.target.body.end = bodyEnd;
+                hd.target.body.text = this.src.slice(bodyPos, bodyEnd);
+                if (this.hereDocClosingPos !== -1)
+                    hd.target.closing = { pos: this.hereDocClosingPos, end: this.hereDocClosingEnd };
+            }
+        }
+        pending.length = 0;
+    }
+    hereDocClosingPos = -1;
+    hereDocClosingEnd = -1;
+    // Advance past the heredoc body and its delimiter line; return the body end
+    // (start of the delimiter line, or srcEnd when delimited by end-of-input).
+    // With parenEnds (inside $(...)), a line starting with the delimiter directly
+    // followed by ")" also terminates the body, resuming at the ")" — bash treats
+    // the substitution's closing paren as end-of-file for its heredocs.
+    // `join` crosses `\`+newline pairs, which an unquoted delimiter may straddle.
+    matchHereDocDelimiter(delimiter, lineStart, end, join) {
+        const src = this.src;
+        let pos = lineStart;
+        for (let i = 0; i < delimiter.length;) {
+            if (join && src.charCodeAt(pos) === CH_BACKSLASH && pos + 1 < end && src.charCodeAt(pos + 1) === CH_NL) {
+                pos += 2;
+                continue;
+            }
+            if (pos >= end || src.charCodeAt(pos) !== delimiter.charCodeAt(i))
+                return -1;
+            pos++;
+            i++;
+        }
+        return pos;
+    }
+    // A `\` consumes the next character, so `\`+newline continues the line and `\\` does not.
+    logicalLineEnd(from, end, join) {
+        const src = this.src;
+        let lineEnd = src.indexOf("\n", from);
+        while (lineEnd !== -1 && lineEnd < end) {
+            if (!join)
+                return lineEnd;
+            let backslashes = lineEnd;
+            while (backslashes > from && src.charCodeAt(backslashes - 1) === CH_BACKSLASH)
+                backslashes--;
+            if ((lineEnd - backslashes) % 2 === 0)
+                return lineEnd;
+            from = lineEnd + 1;
+            lineEnd = src.indexOf("\n", from);
+        }
+        return end;
+    }
+    skipHereDocBody(delimiter, strip, parenEnds = false, quoted = false) {
+        this.hereDocClosingPos = -1;
+        this.hereDocClosingEnd = -1;
+        const src = this.src;
+        const len = this.srcEnd;
+        while (this.pos < len) {
+            let lineStart = this.pos;
+            const lineEnd = this.logicalLineEnd(lineStart, len, !quoted);
+            for (;;) {
+                const before = lineStart;
+                if (strip)
+                    while (lineStart < lineEnd && src.charCodeAt(lineStart) === CH_TAB)
+                        lineStart++;
+                if (!quoted)
+                    lineStart = skipLineContinuations(src, lineStart, lineEnd);
+                if (lineStart === before)
+                    break;
+            }
+            let afterDelim = this.matchHereDocDelimiter(delimiter, lineStart, lineEnd, !quoted);
+            if (afterDelim !== -1 && !quoted)
+                afterDelim = skipLineContinuations(src, afterDelim, lineEnd);
+            if (afterDelim === lineEnd) {
+                const bodyEnd = this.pos;
+                if (!parenEnds || !this.parenBoundary || lineEnd !== len) {
+                    this.hereDocClosingPos = lineStart;
+                    this.hereDocClosingEnd = lineEnd;
+                }
+                this.pos = lineEnd < len ? lineEnd + 1 : lineEnd;
+                return bodyEnd;
+            }
+            // A line starting with the delimiter also ends the body when a `)` follows on the same
+            // logical line; the scan then resumes mid-line, right after the delimiter.
+            if (parenEnds && afterDelim !== -1) {
+                let paren = afterDelim;
+                while (paren < lineEnd && src.charCodeAt(paren) !== CH_RPAREN)
+                    paren++;
+                if (paren < lineEnd || (this.parenBoundary && lineEnd === len)) {
+                    const bodyEnd = this.pos;
+                    this.pos = afterDelim;
+                    return bodyEnd;
+                }
+            }
+            this.pos = lineEnd < len ? lineEnd + 1 : lineEnd;
+        }
+        return this.pos;
+    }
+    _wordText = "";
+    _wordRaw = false;
+    _wordQuoted = false;
+    _wordHasExpansions = false;
+    _wordKeywordEligible = false;
+    _wordIsAssignment;
+    _wordAssignmentOperatorPos;
+    _wordParts = null;
+    _resultText = "";
+    // True when the last $-construct's value is exactly its raw source span.
+    _resultIsRaw = true;
+    _resultHasExpansion = false;
+    _resultPart;
+    // Set by extractBalanced when the input ended before the closing paren, so
+    // callers can report the construct they were scanning.
+    _unbalanced = false;
+    // Set by scanArithmeticBody when the construct turns out not to be arithmetic, so the
+    // caller can re-read it as a subshell or command substitution instead.
+    _notArithmetic = false;
+    _arithUnterminated = false;
+    _dqText = "";
+    _dqHasExpansions = false;
+    _dqParts = null;
+    // Content end (before the closing quote, or end of input when unterminated).
+    _dqEnd = 0;
+    _hereDelim = "";
+    _hereQuoted = false;
+    readWord(out, ctx, tokenStart = 0) {
+        this.readWordText();
+        if (ctx === LexContext.Normal) {
+            const next = this.pos < this.srcEnd ? this.src.charCodeAt(this.pos) : 0;
+            if (!this._wordRaw || (next !== CH_LT && next !== CH_GT)) {
+                setSpanToken(out, Token.Word, tokenStart, this.pos, this._wordRaw);
+                out.keywordEligible = this._wordKeywordEligible;
+                return;
+            }
+        }
+        this.classifyWord(out, ctx, tokenStart);
+    }
+    isRedirectVariable(start, end) {
+        const src = this.src;
+        for (let i = start; i < end; i++) {
+            const c = src.charCodeAt(i);
+            if (c === CH_LBRACKET && i > start) {
+                return (i + 2 < end && src.charCodeAt(end - 1) === CH_RBRACKET && this.findClosingBracket(i + 1, end) === end - 1);
+            }
+            if (c >= 128 || !(isIdChar[c] & (i === start ? 1 : 2)))
+                return false;
+        }
+        return end > start;
+    }
+    readArrayElement(out, tokenStart) {
+        const close = this.findClosingBracket(tokenStart + 1);
+        if (close === -1)
+            return false;
+        this.pos = close + 1;
+        this.readWordText();
+        setSpanToken(out, Token.Word, tokenStart, this.pos, true);
+        return true;
+    }
+    classifyWord(out, ctx, tokenStart) {
+        const src = this.src;
+        const raw = this._wordRaw;
+        const hasExpansions = this._wordHasExpansions;
+        const quoted = this._wordQuoted;
+        const keywordEligible = this._wordKeywordEligible;
+        const isAssignment = this._wordIsAssignment;
+        let assignmentOpPos = this._wordAssignmentOperatorPos;
+        const wordEnd = this.pos;
+        const wordLen = wordEnd - tokenStart;
+        // Only keyword classification needs a non-raw word's processed value.
+        let value = null;
+        if (!raw && !hasExpansions && keywordEligible && (ctx === LexContext.CommandStart || ctx === LexContext.TestMode)) {
+            const nextCh = wordEnd < this.srcEnd ? src.charCodeAt(wordEnd) : 0;
+            if ((!quoted && wordLen <= 16) || nextCh === CH_LT || nextCh === CH_GT) {
+                value = this.wordValueOf(tokenStart, wordEnd);
+            }
+        }
+        if (ctx === LexContext.CommandStart && keywordEligible) {
+            if (raw) {
+                if (wordLen <= 8) {
+                    const reserved = matchReservedWord(src, tokenStart, wordLen);
+                    if (reserved !== undefined) {
+                        setSpanToken(out, reserved, tokenStart, wordEnd, true);
+                        return;
+                    }
+                }
+                if (wordLen === 2 &&
+                    src.charCodeAt(tokenStart) === CH_LBRACKET &&
+                    src.charCodeAt(tokenStart + 1) === CH_LBRACKET) {
+                    setSpanToken(out, Token.DblLBracket, tokenStart, wordEnd, true);
+                    return;
+                }
+            }
+            else if (value !== null && value.length > 0) {
+                const fc = value.charCodeAt(0);
+                if ((fc >= CH_a && fc <= CH_z && value.length <= 8) || fc === CH_BANG || fc === CH_LBRACE || fc === CH_RBRACE) {
+                    const reserved = RESERVED_WORDS.get(value);
+                    if (reserved !== undefined) {
+                        setToken(out, reserved, value, tokenStart, wordEnd);
+                        return;
+                    }
+                }
+                if (fc === CH_LBRACKET && value === "[[") {
+                    setToken(out, Token.DblLBracket, value, tokenStart, wordEnd);
+                    return;
+                }
+            }
+        }
+        if (ctx === LexContext.CommandStart || ctx === LexContext.CommandPrefix || ctx === LexContext.Declaration) {
+            if (isAssignment === undefined) {
+                // Fast-path word (value === raw span): detect assignment positionally.
+                let eq = -1;
+                let bracket = false;
+                for (let i = tokenStart + 1; i < wordEnd; i++) {
+                    const c = src.charCodeAt(i);
+                    if (c === CH_EQ) {
+                        eq = i;
+                        break;
+                    }
+                    if (c === CH_LBRACKET)
+                        bracket = true;
+                }
+                if (eq !== -1) {
+                    const state = scanAssignmentPrefix(src, tokenStart, wordEnd, ASSIGNMENT_NAME_START);
+                    if (isMatchedAssignment(state))
+                        assignmentOpPos = assignmentOperatorPos(state);
+                }
+                else if (ctx !== LexContext.Declaration &&
+                    bracket &&
+                    wordEnd < this.srcEnd &&
+                    scanAssignmentPrefix(src, tokenStart, wordEnd, ASSIGNMENT_NAME_START) >= ASSIGNMENT_INDEX_BASE) {
+                    // The second pass leaves the fast path, setting `_wordIsAssignment`, so this
+                    // cannot recur.
+                    this.pos = tokenStart;
+                    this.readWordText(true);
+                    this.classifyWord(out, ctx, tokenStart);
+                    return;
+                }
+            }
+            if (assignmentOpPos !== undefined) {
+                setSpanToken(out, Token.Assignment, tokenStart, wordEnd, raw);
+                if (value !== null)
+                    out._value = value;
+                out.assignmentOperatorPos = assignmentOpPos;
+                return;
+            }
+        }
+        // `]]` is reserved only where it can close a `[[`; operands and wordlist entries, which
+        // read Normal, are ordinary words, as is a `]]` demoted by a command prefix.
+        if ((ctx === LexContext.CommandStart || ctx === LexContext.TestMode) && keywordEligible) {
+            if (raw) {
+                if (wordLen === 2 &&
+                    src.charCodeAt(tokenStart) === CH_RBRACKET &&
+                    src.charCodeAt(tokenStart + 1) === CH_RBRACKET) {
+                    setSpanToken(out, Token.DblRBracket, tokenStart, wordEnd, true);
+                    return;
+                }
+            }
+            else if (value === "]]") {
+                setToken(out, Token.DblRBracket, value, tokenStart, wordEnd);
+                return;
+            }
+        }
+        // FD number prefix: all-digit word followed by < or > → redirect with fd
+        if (!hasExpansions && this.pos < this.srcEnd) {
+            const nc = src.charCodeAt(this.pos);
+            if (nc === CH_LT || nc === CH_GT) {
+                if (raw) {
+                    const fc = src.charCodeAt(tokenStart);
+                    if (fc >= CH_0 && fc <= CH_9 && isAllDigitsRange(src, tokenStart, wordEnd)) {
+                        const fd = Number.parseInt(src.slice(tokenStart, wordEnd), 10);
+                        if (this.readRedirection(out, tokenStart)) {
+                            out.fileDescriptor = fd;
+                            out.descriptorEnd = wordEnd;
+                            return;
+                        }
+                    }
+                    if (fc === CH_LBRACE &&
+                        src.charCodeAt(wordEnd - 1) === CH_RBRACE &&
+                        this.isRedirectVariable(tokenStart + 1, wordEnd - 1)) {
+                        const varname = src.slice(tokenStart + 1, wordEnd - 1);
+                        if (this.readRedirection(out, tokenStart)) {
+                            out.variableName = varname;
+                            out.descriptorEnd = wordEnd;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        setSpanToken(out, Token.Word, tokenStart, wordEnd, raw);
+        if (value !== null)
+            out._value = value;
+        out.keywordEligible = keywordEligible;
+    }
+    // `subscripts` re-reads a word known to stop inside an array subscript, where
+    // metacharacters are ordinary text.
+    readWordText(subscripts = false) {
+        const src = this.src;
+        const len = this.srcEnd;
+        let pos = this.pos;
+        // Fast path: scan a single run of plain chars (covers most words)
+        const fastStart = pos;
+        let exitCh = 0;
+        while (pos < len) {
+            const c = src.charCodeAt(pos);
+            if (c < 128 && charType[c]) {
+                exitCh = c;
+                break;
+            }
+            pos++;
+        }
+        if (pos >= len ||
+            (charType[exitCh] & 1 &&
+                !(exitCh === CH_LPAREN && pos > fastStart && extglobPrefix[src.charCodeAt(pos - 1)]) &&
+                !subscripts)) {
+            this.pos = pos;
+            this._wordText = (this._buildParts || this._buildValue) && pos > fastStart ? src.slice(fastStart, pos) : "";
+            this._wordRaw = true;
+            this._wordQuoted = false;
+            this._wordHasExpansions = false;
+            this._wordKeywordEligible = true;
+            this._wordIsAssignment = undefined;
+            this._wordAssignmentOperatorPos = undefined;
+            if (this._buildParts)
+                this._wordParts = null;
+            return;
+        }
+        // Slow path: word contains quotes, expansions, escapes, etc. `text` (the
+        // processed value) is only assembled when building; the token path tracks
+        // positions and flags plus the last value char (for extglob prefixes) and
+        // whether the value still equals the raw span.
+        const bp = this._buildParts;
+        const bt = bp || this._buildValue;
+        let text = bt && pos > fastStart ? src.slice(fastStart, pos) : "";
+        let quoted = false;
+        let hasExpansions = false;
+        let keywordEligible = true;
+        let valueIsRaw = true;
+        let lastValueChar = pos > fastStart ? src.charCodeAt(pos - 1) : 0;
+        let assignmentState = scanAssignmentPrefix(src, fastStart, pos, ASSIGNMENT_NAME_START);
+        let parts;
+        let litBuf = "";
+        let litStart = 0;
+        if (bp) {
+            parts = [];
+            litBuf = text; // fast-path prefix is literal
+            litStart = fastStart;
+        }
+        while (pos < len) {
+            const ch = src.charCodeAt(pos);
+            if (ch >= 128 || !charType[ch]) {
+                const runStart = pos;
+                pos++;
+                while (pos < len) {
+                    const c = src.charCodeAt(pos);
+                    if (c < 128 && charType[c])
+                        break;
+                    pos++;
+                }
+                lastValueChar = src.charCodeAt(pos - 1);
+                assignmentState = scanAssignmentPrefix(src, runStart, pos, assignmentState);
+                if (bt) {
+                    const chunk = src.slice(runStart, pos);
+                    text += chunk;
+                    if (bp)
+                        litBuf += chunk;
+                }
+                continue;
+            }
+            if (charType[ch] & 1) {
+                if (ch === CH_LPAREN && lastValueChar < 128 && extglobPrefix[lastValueChar]) {
+                    keywordEligible = false;
+                    const prefixChar = lastValueChar;
+                    pos++;
+                    const innerStart = pos;
+                    const close = this.findClosingShellDelimiter(innerStart, len, CH_RPAREN, prefixChar === CH_EQ);
+                    const patternEnd = close === -1 ? len : close;
+                    pos = close === -1 ? len : close + 1;
+                    if (close === -1)
+                        this.errors.push({ message: "unterminated extended glob", pos: innerStart - 2 });
+                    lastValueChar = src.charCodeAt(pos - 1);
+                    if (bt) {
+                        const eg = "(" + src.slice(innerStart, pos);
+                        text += eg;
+                        // Create ExtendedGlob part for real extglob operators (not = which is array assignment)
+                        if (bp && prefixChar !== CH_EQ) {
+                            let prefixPos = innerStart - 2;
+                            while (src.charCodeAt(prefixPos) === CH_NL && src.charCodeAt(prefixPos - 1) === CH_BACKSLASH) {
+                                prefixPos -= 2;
+                            }
+                            // Remove the prefix char from litBuf (it was appended in the previous iteration)
+                            if (litBuf.length > 0) {
+                                const trimmed = litBuf.slice(0, -1);
+                                if (prefixPos > litStart)
+                                    parts.push({
+                                        type: "Literal",
+                                        pos: litStart,
+                                        end: prefixPos,
+                                        value: trimmed,
+                                        text: src.slice(litStart, prefixPos),
+                                    });
+                                litBuf = "";
+                            }
+                            const op = extglobOp[prefixChar];
+                            parts.push({
+                                type: "ExtendedGlob",
+                                pos: prefixPos,
+                                end: pos,
+                                text: src.slice(prefixPos, pos),
+                                operator: op,
+                                pattern: src.slice(innerStart, patternEnd),
+                                parts: hasEmbeddedWordStructure(src, innerStart, patternEnd)
+                                    ? this.parseSubFieldWord(innerStart, patternEnd).parts
+                                    : undefined,
+                            });
+                            litStart = pos;
+                        }
+                        else if (bp) {
+                            litBuf += eg;
+                        }
+                    }
+                    continue;
+                }
+                if (subscripts && assignmentState >= ASSIGNMENT_INDEX_BASE) {
+                    const close = this.findClosingBracket(pos);
+                    if (close !== -1) {
+                        const spanEnd = close + 1;
+                        assignmentState = scanAssignmentPrefix(src, pos, spanEnd, assignmentState);
+                        lastValueChar = src.charCodeAt(close);
+                        if (bt) {
+                            const chunk = src.slice(pos, spanEnd);
+                            text += chunk;
+                            if (bp)
+                                litBuf += chunk;
+                        }
+                        pos = spanEnd;
+                        continue;
+                    }
+                }
+                break;
+            }
+            if (ch === CH_BACKSLASH) {
+                pos++;
+                if (pos < len) {
+                    if (src.charCodeAt(pos) === CH_NL) {
+                        pos++;
+                        valueIsRaw = false;
+                    }
+                    else {
+                        if (assignmentState >= 0 && assignmentState < ASSIGNMENT_INDEX_BASE)
+                            assignmentState = ASSIGNMENT_INVALID;
+                        quoted = true;
+                        keywordEligible = false;
+                        valueIsRaw = false;
+                        lastValueChar = src.charCodeAt(pos);
+                        if (bt) {
+                            text += src[pos];
+                            if (bp)
+                                litBuf += src[pos];
+                        }
+                        pos++;
+                    }
+                }
+                else {
+                    // A backslash at end of input escapes nothing and stays as itself.
+                    if (assignmentState >= 0 && assignmentState < ASSIGNMENT_INDEX_BASE)
+                        assignmentState = ASSIGNMENT_INVALID;
+                    quoted = true;
+                    keywordEligible = false;
+                    lastValueChar = CH_BACKSLASH;
+                    if (bt) {
+                        text += "\\";
+                        if (bp)
+                            litBuf += "\\";
+                    }
+                }
+                continue;
+            }
+            if (ch === CH_SQUOTE) {
+                const sqStart = pos;
+                if (assignmentState >= 0 && assignmentState < ASSIGNMENT_INDEX_BASE)
+                    assignmentState = ASSIGNMENT_INVALID;
+                quoted = true;
+                keywordEligible = false;
+                valueIsRaw = false;
+                pos++;
+                const start = pos;
+                while (pos < len && src.charCodeAt(pos) !== CH_SQUOTE)
+                    pos++;
+                if (pos > start)
+                    lastValueChar = src.charCodeAt(pos - 1);
+                const value = bt ? src.slice(start, pos) : "";
+                if (bt)
+                    text += value;
+                if (pos < len)
+                    pos++;
+                else
+                    this.errors.push({ message: "unterminated single quote", pos: start - 1 });
+                if (bp) {
+                    if (sqStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: sqStart,
+                            value: litBuf,
+                            text: src.slice(litStart, sqStart),
+                        });
+                        litBuf = "";
+                    }
+                    parts.push({ type: "SingleQuoted", pos: sqStart, end: pos, value, text: src.slice(sqStart, pos) });
+                    litStart = pos;
+                }
+                continue;
+            }
+            if (ch === CH_DQUOTE) {
+                const dqStart = pos;
+                if (assignmentState >= 0 && assignmentState < ASSIGNMENT_INDEX_BASE)
+                    assignmentState = ASSIGNMENT_INVALID;
+                quoted = true;
+                keywordEligible = false;
+                valueIsRaw = false;
+                pos++;
+                this.pos = pos;
+                this.readDoubleQuoted();
+                pos = this.pos;
+                if (this._dqEnd > dqStart + 1)
+                    lastValueChar = src.charCodeAt(this._dqEnd - 1);
+                if (this._dqHasExpansions)
+                    hasExpansions = true;
+                if (bt)
+                    text += this._dqText;
+                if (bp) {
+                    if (dqStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: dqStart,
+                            value: litBuf,
+                            text: src.slice(litStart, dqStart),
+                        });
+                        litBuf = "";
+                    }
+                    const dqText = src.slice(dqStart, pos);
+                    parts.push({
+                        type: "DoubleQuoted",
+                        pos: dqStart,
+                        end: pos,
+                        text: dqText,
+                        parts: this._dqParts ?? [
+                            {
+                                type: "Literal",
+                                pos: dqStart + 1,
+                                end: this._dqEnd,
+                                value: this._dqText,
+                                text: src.slice(dqStart + 1, this._dqEnd),
+                            },
+                        ],
+                    });
+                    litStart = pos;
+                }
+                continue;
+            }
+            if (ch === CH_DOLLAR) {
+                keywordEligible = false;
+                const dollarStart = pos;
+                if (assignmentState >= 0 && assignmentState < ASSIGNMENT_INDEX_BASE)
+                    assignmentState = ASSIGNMENT_INVALID;
+                this.pos = pos;
+                this.readDollar();
+                pos = this.pos;
+                if (!this._resultIsRaw)
+                    valueIsRaw = false;
+                if (pos > dollarStart)
+                    lastValueChar = src.charCodeAt(pos - 1);
+                if (this._resultHasExpansion)
+                    hasExpansions = true;
+                if (bt)
+                    text += this._resultText;
+                if (bp) {
+                    if (this._resultPart) {
+                        if (dollarStart > litStart) {
+                            parts.push({
+                                type: "Literal",
+                                pos: litStart,
+                                end: dollarStart,
+                                value: litBuf,
+                                text: src.slice(litStart, dollarStart),
+                            });
+                            litBuf = "";
+                        }
+                        parts.push(this._resultPart);
+                        litStart = pos;
+                    }
+                    else {
+                        litBuf += this._resultText;
+                    }
+                }
+                continue;
+            }
+            if (ch === CH_BACKTICK) {
+                keywordEligible = false;
+                const btStart = pos;
+                if (assignmentState >= 0 && assignmentState < ASSIGNMENT_INDEX_BASE)
+                    assignmentState = ASSIGNMENT_INVALID;
+                this.pos = pos;
+                this.readBacktickExpansion();
+                pos = this.pos;
+                valueIsRaw = false;
+                lastValueChar = src.charCodeAt(pos - 1);
+                hasExpansions = true;
+                if (bt)
+                    text += this._resultText;
+                if (bp) {
+                    if (btStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: btStart,
+                            value: litBuf,
+                            text: src.slice(litStart, btStart),
+                        });
+                        litBuf = "";
+                    }
+                    parts.push(this._resultPart);
+                    litStart = pos;
+                }
+                continue;
+            }
+            if (ch === CH_LBRACE) {
+                if (assignmentState >= 0 && assignmentState < ASSIGNMENT_INDEX_BASE)
+                    assignmentState = ASSIGNMENT_INVALID;
+                const braceEnd = scanBraceExpansion(src, pos, len);
+                if (braceEnd > 0) {
+                    keywordEligible = false;
+                    lastValueChar = src.charCodeAt(braceEnd - 1);
+                    if (bt) {
+                        const braceText = src.slice(pos, braceEnd);
+                        text += braceText;
+                        if (bp) {
+                            if (pos > litStart) {
+                                parts.push({
+                                    type: "Literal",
+                                    pos: litStart,
+                                    end: pos,
+                                    value: litBuf,
+                                    text: src.slice(litStart, pos),
+                                });
+                                litBuf = "";
+                            }
+                            parts.push({
+                                type: "BraceExpansion",
+                                pos,
+                                end: braceEnd,
+                                text: braceText,
+                                parts: hasEmbeddedWordStructure(src, pos + 1, braceEnd - 1)
+                                    ? this.parseSubFieldWord(pos + 1, braceEnd - 1).parts
+                                    : undefined,
+                            });
+                            litStart = braceEnd;
+                        }
+                    }
+                    pos = braceEnd;
+                    continue;
+                }
+                lastValueChar = CH_LBRACE;
+                if (bt) {
+                    text += "{";
+                    if (bp)
+                        litBuf += "{";
+                }
+                pos++;
+                continue;
+            }
+            pos++;
+        }
+        if (bp && pos > litStart)
+            parts.push({ type: "Literal", pos: litStart, end: pos, value: litBuf, text: src.slice(litStart, pos) });
+        this.pos = pos;
+        this._wordText = text;
+        this._wordRaw = valueIsRaw;
+        this._wordQuoted = quoted;
+        this._wordHasExpansions = hasExpansions;
+        this._wordKeywordEligible = keywordEligible;
+        this._wordIsAssignment = isMatchedAssignment(assignmentState);
+        this._wordAssignmentOperatorPos = this._wordIsAssignment ? assignmentOperatorPos(assignmentState) : undefined;
+        if (bp) {
+            // Only store parts if they add structure beyond a single literal
+            this._wordParts = parts.length > 1 || (parts.length === 1 && parts[0].type !== "Literal") ? parts : null;
+        }
+    }
+    readInnerWordText() {
+        const src = this.src;
+        const len = this.srcEnd;
+        let pos = this.pos;
+        let text = "";
+        const bp = this._buildParts;
+        let parts;
+        let litBuf = "";
+        let litStart = 0;
+        if (bp) {
+            parts = [];
+            litStart = pos;
+        }
+        while (pos < len) {
+            const ch = src.charCodeAt(pos);
+            if (ch === CH_BACKSLASH) {
+                pos++;
+                if (pos < len) {
+                    if (src.charCodeAt(pos) === CH_NL) {
+                        pos++;
+                    }
+                    else {
+                        const escaped = src[pos++];
+                        text += escaped;
+                        if (bp)
+                            litBuf += escaped;
+                    }
+                }
+                continue;
+            }
+            if (ch === CH_SQUOTE) {
+                const sqStart = pos;
+                pos++;
+                const start = pos;
+                while (pos < len && src.charCodeAt(pos) !== CH_SQUOTE)
+                    pos++;
+                const value = src.slice(start, pos);
+                text += value;
+                if (pos < len)
+                    pos++;
+                if (bp) {
+                    if (sqStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: sqStart,
+                            value: litBuf,
+                            text: src.slice(litStart, sqStart),
+                        });
+                        litBuf = "";
+                    }
+                    parts.push({ type: "SingleQuoted", pos: sqStart, end: pos, value, text: src.slice(sqStart, pos) });
+                    litStart = pos;
+                }
+                continue;
+            }
+            if (ch === CH_DQUOTE) {
+                const dqStart = pos;
+                pos++;
+                this.pos = pos;
+                this.readDoubleQuoted();
+                pos = this.pos;
+                text += this._dqText;
+                if (bp) {
+                    if (dqStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: dqStart,
+                            value: litBuf,
+                            text: src.slice(litStart, dqStart),
+                        });
+                        litBuf = "";
+                    }
+                    const dqText = src.slice(dqStart, pos);
+                    parts.push({
+                        type: "DoubleQuoted",
+                        pos: dqStart,
+                        end: pos,
+                        text: dqText,
+                        parts: this._dqParts ?? [
+                            {
+                                type: "Literal",
+                                pos: dqStart + 1,
+                                end: this._dqEnd,
+                                value: this._dqText,
+                                text: src.slice(dqStart + 1, this._dqEnd),
+                            },
+                        ],
+                    });
+                    litStart = pos;
+                }
+                continue;
+            }
+            if (ch === CH_DOLLAR) {
+                const dollarStart = pos;
+                this.pos = pos;
+                this.readDollar();
+                pos = this.pos;
+                text += this._resultText;
+                if (bp) {
+                    if (this._resultPart) {
+                        if (dollarStart > litStart) {
+                            parts.push({
+                                type: "Literal",
+                                pos: litStart,
+                                end: dollarStart,
+                                value: litBuf,
+                                text: src.slice(litStart, dollarStart),
+                            });
+                            litBuf = "";
+                        }
+                        parts.push(this._resultPart);
+                        litStart = pos;
+                    }
+                    else {
+                        litBuf += this._resultText;
+                    }
+                }
+                continue;
+            }
+            if (ch === CH_BACKTICK) {
+                const btStart = pos;
+                this.pos = pos;
+                this.readBacktickExpansion();
+                pos = this.pos;
+                text += this._resultText;
+                if (bp) {
+                    if (btStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: btStart,
+                            value: litBuf,
+                            text: src.slice(litStart, btStart),
+                        });
+                        litBuf = "";
+                    }
+                    parts.push(this._resultPart);
+                    litStart = pos;
+                }
+                continue;
+            }
+            if ((ch === CH_LT || ch === CH_GT) && pos + 1 < len && src.charCodeAt(pos + 1) === CH_LPAREN) {
+                const psStart = pos;
+                this.pos = pos + 2;
+                const inner = this.extractBalanced();
+                pos = this.pos;
+                const raw = src.slice(psStart, pos);
+                text += raw;
+                if (bp) {
+                    if (psStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: psStart,
+                            value: litBuf,
+                            text: src.slice(litStart, psStart),
+                        });
+                        litBuf = "";
+                    }
+                    const part = {
+                        type: "ProcessSubstitution",
+                        pos: psStart,
+                        end: pos,
+                        text: raw,
+                        operator: ch === CH_LT ? "<" : ">",
+                        script: undefined,
+                    };
+                    parts.push(part);
+                    this.collect(part, inner, psStart + 2, !this._unbalanced);
+                    litStart = pos;
+                }
+                continue;
+            }
+            text += src[pos];
+            if (bp)
+                litBuf += src[pos];
+            pos++;
+        }
+        if (bp && pos > litStart)
+            parts.push({ type: "Literal", pos: litStart, end: pos, value: litBuf, text: src.slice(litStart, pos) });
+        this.pos = pos;
+        this._wordText = text;
+        this._wordRaw = false;
+        this._wordQuoted = false;
+        this._wordHasExpansions = false;
+        this._wordKeywordEligible = false;
+        if (bp) {
+            this._wordParts = parts.length > 1 || (parts.length === 1 && parts[0].type !== "Literal") ? parts : null;
+        }
+    }
+    // Parse a parameter-expansion sub-field (operand, slice bound, replacement pattern) over
+    // the window [start, end) of the original source. Parsing in place — rather than against a
+    // detached slice — gives the word and any nested substitutions absolute offsets, and
+    // composes through nested ${...}. The `${...}` inner is a verbatim substring of the
+    // source, so every sub-field offset maps straight back.
+    parseSubFieldWord(start, end) {
+        if (start >= end)
+            return new WordImpl("", start, start);
+        // Sub-fields nest through readInnerWordText (nested expansions, arithmetic embedded
+        // words); once the shared budget is spent, keep the raw span as an unstructured word.
+        if (this._nestingDepth >= MAX_SYNTAX_NESTING)
+            return new WordImpl(this.src.slice(start, end), start, end);
+        this._nestingDepth++;
+        const savedEnd = this.srcEnd;
+        const savedPos = this.pos;
+        const savedText = this._wordText;
+        const savedParts = this._wordParts;
+        const savedQuoted = this._wordQuoted;
+        const savedKeywordEligible = this._wordKeywordEligible;
+        this.srcEnd = end;
+        this.pos = start;
+        this.readInnerWordText();
+        // text is the raw source span (so source.slice(pos, end) === text holds, as for every
+        // other word); value resolves quotes via parts.
+        const word = new WordImpl(this.src.slice(start, end), start, end);
+        if (this._buildParts && this._wordParts) {
+            word.parts = this._wordParts;
+        }
+        this.srcEnd = savedEnd;
+        this.pos = savedPos;
+        this._wordText = savedText;
+        this._wordParts = savedParts;
+        this._wordQuoted = savedQuoted;
+        this._wordKeywordEligible = savedKeywordEligible;
+        this._nestingDepth--;
+        return word;
+    }
+    skipSQ() {
+        while (this.pos < this.srcEnd && this.src.charCodeAt(this.pos) !== CH_SQUOTE)
+            this.pos++;
+        if (this.pos < this.srcEnd)
+            this.pos++;
+    }
+    skipAnsiCQuoted() {
+        const quotePos = this.pos - 1;
+        const result = decodeAnsiCQuoted(this.src, this.pos, this.srcEnd);
+        this.pos = result.end;
+        if (!result.closed)
+            this.errors.push({ message: "unterminated ANSI-C quote", pos: quotePos });
+    }
+    skipDQ() {
+        const src = this.src;
+        const len = this.srcEnd;
+        while (this.pos < len) {
+            const ch = src.charCodeAt(this.pos);
+            if (ch === CH_DQUOTE) {
+                this.pos++;
+                return;
+            }
+            if (ch === CH_BACKSLASH) {
+                this.pos += 2;
+                continue;
+            }
+            if (ch === CH_DOLLAR && this.pos + 1 < len) {
+                const next = src.charCodeAt(this.pos + 1);
+                if (next === CH_LPAREN) {
+                    const csStart = this.pos;
+                    this.pos += 2;
+                    this.extractBalanced();
+                    if (this._unbalanced)
+                        this.errors.push({ message: "unterminated command substitution", pos: csStart });
+                    continue;
+                }
+                if (next === CH_LBRACE) {
+                    this.pos += 2;
+                    let d = 1;
+                    while (this.pos < len && d > 0) {
+                        const c = src.charCodeAt(this.pos);
+                        if (c === CH_RBRACE) {
+                            if (--d === 0) {
+                                this.pos++;
+                                break;
+                            }
+                        }
+                        else if (c === CH_LBRACE && this.pos > 0 && src.charCodeAt(this.pos - 1) === CH_DOLLAR)
+                            d++;
+                        else if (c === CH_BACKSLASH) {
+                            this.pos++;
+                        }
+                        else if (c === CH_SQUOTE) {
+                            this.pos++;
+                            this.skipSQ();
+                            continue;
+                        }
+                        else if (c === CH_DQUOTE) {
+                            this.pos++;
+                            this.skipDQ();
+                            continue;
+                        }
+                        this.pos++;
+                    }
+                    continue;
+                }
+            }
+            if (ch === CH_BACKTICK) {
+                this.pos++;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+                    if (src.charCodeAt(this.pos) === CH_BACKSLASH)
+                        this.pos++;
+                    this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+                continue;
+            }
+            this.pos++;
+        }
+    }
+    skipSpacesAndTabs() {
+        const src = this.src;
+        const len = this.srcEnd;
+        while (this.pos < len) {
+            const ch = src.charCodeAt(this.pos);
+            if (ch === CH_SPACE || ch === CH_TAB)
+                this.pos++;
+            else if (ch === CH_BACKSLASH && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_NL)
+                this.pos += 2;
+            else
+                break;
+        }
+    }
+    readDoubleQuoted() {
+        const src = this.src;
+        const len = this.srcEnd;
+        const contentStart = this.pos;
+        let hasExpansions = false;
+        const bp = this._buildParts;
+        const bt = bp || this._buildValue;
+        // Fast path: pure literal content (no $, `, or \ — just find closing ")
+        if (!bp) {
+            let p = this.pos;
+            while (p < len) {
+                const c = src.charCodeAt(p);
+                if (c === CH_DQUOTE) {
+                    this._dqText = bt ? src.slice(contentStart, p) : "";
+                    this._dqEnd = p;
+                    this.pos = p + 1;
+                    this._dqHasExpansions = false;
+                    this._dqParts = null;
+                    return;
+                }
+                if (c === CH_DOLLAR || c === CH_BACKTICK || c === CH_BACKSLASH)
+                    break;
+                p++;
+            }
+            // Fall through to general path
+        }
+        let text = "";
+        let parts = null;
+        let litBuf = "";
+        let litStart = bp ? this.pos : 0;
+        while (this.pos < len && src.charCodeAt(this.pos) !== CH_DQUOTE) {
+            // Scan run of plain chars inside double quotes
+            const runStart = this.pos;
+            while (this.pos < len) {
+                const c = src.charCodeAt(this.pos);
+                if (c === CH_DQUOTE || c === CH_BACKSLASH || c === CH_DOLLAR || c === CH_BACKTICK)
+                    break;
+                this.pos++;
+            }
+            if (bt && this.pos > runStart) {
+                const chunk = src.slice(runStart, this.pos);
+                text += chunk;
+                if (bp)
+                    litBuf += chunk;
+            }
+            if (this.pos >= len || src.charCodeAt(this.pos) === CH_DQUOTE)
+                break;
+            const ch = src.charCodeAt(this.pos);
+            if (ch === CH_BACKSLASH) {
+                this.pos++;
+                if (this.pos < len) {
+                    const next = src.charCodeAt(this.pos);
+                    if (next === CH_NL) {
+                        this.pos++;
+                        continue;
+                    }
+                    if (bt) {
+                        if (next === CH_DOLLAR || next === CH_BACKTICK || next === CH_DQUOTE || next === CH_BACKSLASH) {
+                            const c = src[this.pos];
+                            text += c;
+                            if (bp)
+                                litBuf += c;
+                        }
+                        else {
+                            const pair = "\\" + src[this.pos];
+                            text += pair;
+                            if (bp)
+                                litBuf += pair;
+                        }
+                    }
+                    this.pos++;
+                }
+                continue;
+            }
+            if (ch === CH_DOLLAR) {
+                // Inside double quotes `$"` and `$'` are a literal $: no locale string, no ANSI-C quote.
+                const afterDollar = this.pos + 1 < len ? src.charCodeAt(this.pos + 1) : 0;
+                if (afterDollar === CH_DQUOTE || afterDollar === CH_SQUOTE) {
+                    if (bt) {
+                        text += "$";
+                        if (bp)
+                            litBuf += "$";
+                    }
+                    this.pos++;
+                    continue;
+                }
+                const expStart = this.pos;
+                this.readDollar();
+                if (bt)
+                    text += this._resultText;
+                if (this._resultHasExpansion)
+                    hasExpansions = true;
+                if (bp) {
+                    const rp = this._resultPart;
+                    if (rp && isDQChild(rp)) {
+                        if (!parts)
+                            parts = [];
+                        if (expStart > litStart) {
+                            parts.push({
+                                type: "Literal",
+                                pos: litStart,
+                                end: expStart,
+                                value: litBuf,
+                                text: src.slice(litStart, expStart),
+                            });
+                            litBuf = "";
+                        }
+                        parts.push(rp);
+                        litStart = this.pos;
+                    }
+                    else {
+                        litBuf += this._resultText;
+                    }
+                }
+                continue;
+            }
+            if (ch === CH_BACKTICK) {
+                const btStart = this.pos;
+                this.readBacktickExpansion(true);
+                if (bt)
+                    text += this._resultText;
+                hasExpansions = true;
+                if (bp && this._resultPart && isDQChild(this._resultPart)) {
+                    if (!parts)
+                        parts = [];
+                    if (btStart > litStart) {
+                        parts.push({
+                            type: "Literal",
+                            pos: litStart,
+                            end: btStart,
+                            value: litBuf,
+                            text: src.slice(litStart, btStart),
+                        });
+                        litBuf = "";
+                    }
+                    parts.push(this._resultPart);
+                    litStart = this.pos;
+                }
+                continue;
+            }
+        }
+        if (bp && parts && this.pos > litStart)
+            parts.push({ type: "Literal", pos: litStart, end: this.pos, value: litBuf, text: src.slice(litStart, this.pos) });
+        this._dqEnd = this.pos;
+        if (this.pos < len)
+            this.pos++; // closing "
+        else
+            this.errors.push({ message: "unterminated double quote", pos: contentStart - 1 });
+        this._dqText = text;
+        this._dqHasExpansions = hasExpansions;
+        this._dqParts = parts;
+    }
+    readDollar() {
+        const dollarPos = this.pos;
+        this.pos++; // skip $
+        const src = this.src;
+        const len = this.srcEnd;
+        const bt = this._buildParts || this._buildValue;
+        if (this.pos >= len) {
+            this._resultText = "$";
+            this._resultIsRaw = true;
+            this._resultHasExpansion = false;
+            this._resultPart = undefined;
+            return;
+        }
+        const logicalPos = skipLineContinuations(src, this.pos, len);
+        if (logicalPos > this.pos &&
+            src.charCodeAt(logicalPos) === CH_LPAREN &&
+            src.charCodeAt(logicalPos + 1) !== CH_LPAREN)
+            this.pos = logicalPos;
+        const ch = src.charCodeAt(this.pos);
+        if (ch === CH_LPAREN) {
+            if (this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+                const savedPos = this.pos;
+                const savedErrors = this.errors.length;
+                this.readArithmeticExpansion(dollarPos);
+                if (!this._notArithmetic)
+                    return;
+                this.errors.length = savedErrors;
+                this.pos = savedPos;
+            }
+            this.readCommandSubstitution(dollarPos);
+            return;
+        }
+        if (ch === CH_LBRACE) {
+            const after = this.pos + 1 < len ? src.charCodeAt(this.pos + 1) : 0;
+            if (after === CH_SPACE || after === CH_TAB || after === CH_NL) {
+                this.readBraceCommandSubstitution();
+                return;
+            }
+            if (after === CH_PIPE) {
+                this.readValueSubstitution();
+                return;
+            }
+            this.readParameterExpansion();
+            return;
+        }
+        if (ch === CH_SQUOTE) {
+            this.pos++;
+            if (bt) {
+                const value = this.readAnsiCQuoted();
+                this._resultText = value;
+                this._resultPart = this._buildParts
+                    ? { type: "AnsiCQuoted", pos: dollarPos, end: this.pos, text: src.slice(dollarPos, this.pos), value }
+                    : undefined;
+            }
+            else {
+                this.skipAnsiCQuoted();
+                this._resultText = "";
+                this._resultPart = undefined;
+            }
+            this._resultIsRaw = false;
+            this._resultHasExpansion = false;
+            return;
+        }
+        if (ch === CH_DQUOTE) {
+            this.pos++;
+            this.readDoubleQuoted();
+            this._resultText = this._dqText;
+            this._resultIsRaw = false;
+            this._resultHasExpansion = this._dqHasExpansions;
+            if (this._buildParts) {
+                const text = src.slice(dollarPos, this.pos);
+                this._resultPart = {
+                    type: "LocaleString",
+                    pos: dollarPos,
+                    end: this.pos,
+                    text,
+                    parts: this._dqParts ?? [
+                        {
+                            type: "Literal",
+                            pos: dollarPos + 2,
+                            end: this._dqEnd,
+                            value: this._dqText,
+                            text: src.slice(dollarPos + 2, this._dqEnd),
+                        },
+                    ],
+                };
+            }
+            else {
+                this._resultPart = undefined;
+            }
+            return;
+        }
+        if (ch === CH_AT ||
+            ch === CH_STAR ||
+            ch === CH_HASH ||
+            ch === CH_QUESTION ||
+            ch === CH_DASH ||
+            ch === CH_DOLLAR ||
+            ch === CH_BANG ||
+            (ch >= CH_0 && ch <= CH_9)) {
+            this.pos++;
+            const text = bt ? src.slice(this.pos - 2, this.pos) : "";
+            this._resultText = text;
+            this._resultIsRaw = true;
+            this._resultHasExpansion = false;
+            this._resultPart = this._buildParts
+                ? { type: "SimpleExpansion", pos: dollarPos, end: this.pos, text }
+                : undefined;
+            return;
+        }
+        if (ch < 128 && isIdChar[ch] & 1) {
+            const namePos = this.pos - 1;
+            while (this.pos < len) {
+                const c = src.charCodeAt(this.pos);
+                if (c < 128 && isIdChar[c] & 2)
+                    this.pos++;
+                else
+                    break;
+            }
+            const text = bt ? src.slice(namePos, this.pos) : "";
+            this._resultText = text;
+            this._resultIsRaw = true;
+            this._resultHasExpansion = false;
+            this._resultPart = this._buildParts
+                ? { type: "SimpleExpansion", pos: dollarPos, end: this.pos, text }
+                : undefined;
+            return;
+        }
+        // $[ expr ] is bash's deprecated spelling of $(( expr )). It runs to the matching ']',
+        // so parentheses inside belong to the expansion instead of ending the word.
+        if (ch === CH_LBRACKET) {
+            const close = this.findClosingArithmeticBracket(this.pos + 1);
+            if (close !== -1) {
+                const bodyStart = this.pos + 1;
+                const body = src.slice(bodyStart, close);
+                this.pos = close + 1;
+                const text = bt ? src.slice(dollarPos, this.pos) : "";
+                this._resultText = text;
+                this._resultIsRaw = true;
+                this._resultHasExpansion = false;
+                this._resultPart = this._buildParts
+                    ? {
+                        type: "ArithmeticExpansion",
+                        pos: bodyStart - 2,
+                        end: this.pos,
+                        text,
+                        expression: this.buildArithmeticExpression(body, bodyStart),
+                    }
+                    : undefined;
+                return;
+            }
+        }
+        this._resultText = "$";
+        this._resultIsRaw = true;
+        this._resultHasExpansion = false;
+        this._resultPart = undefined;
+    }
+    scanArithmeticBody() {
+        this._notArithmetic = false;
+        this._arithUnterminated = false;
+        this.pos += 2;
+        let depth = 1;
+        let parenDepth = 0;
+        let parentParenDepth = 0;
+        let parenDepths;
+        let expansions = 0;
+        let reported = false;
+        const src = this.src;
+        const len = this.srcEnd;
+        const start = this.pos;
+        while (this.pos < len && depth > 0) {
+            const c = src.charCodeAt(this.pos);
+            if (c === CH_BACKSLASH) {
+                this.pos += this.pos + 1 < len ? 2 : 1;
+            }
+            else if (c === CH_SQUOTE) {
+                this.pos++;
+                this.skipSQ();
+            }
+            else if (c === CH_DQUOTE) {
+                this.pos++;
+                this.skipDQ();
+            }
+            else if (c === CH_BACKTICK) {
+                this.pos++;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+                    if (src.charCodeAt(this.pos) === CH_BACKSLASH)
+                        this.pos++;
+                    this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+            }
+            else if (c === CH_DOLLAR &&
+                this.pos + 2 < len &&
+                src.charCodeAt(this.pos + 1) === CH_LPAREN &&
+                src.charCodeAt(this.pos + 2) !== CH_LPAREN) {
+                const dollarPos = this.pos;
+                this.pos += 2;
+                this.extractBalanced();
+                if (this._unbalanced)
+                    this.errors.push({ message: "unterminated command substitution", pos: dollarPos });
+            }
+            else if (c === CH_DOLLAR && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LBRACE) {
+                const close = this.findClosingBrace(this.pos + 2, len);
+                this.pos = close === -1 ? len : close + 1;
+            }
+            else if ((c === CH_LT || c === CH_GT) && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+                this.pos += 2;
+                this.extractBalanced();
+            }
+            else if (c === CH_LPAREN) {
+                if (src.charCodeAt(this.pos - 1) === CH_DOLLAR && src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+                    if (depth === 1)
+                        parentParenDepth = parenDepth;
+                    else
+                        (parenDepths ?? (parenDepths = [])).push(parenDepth);
+                    depth++;
+                    parenDepth = 0;
+                    // Nested $((...)) — count it against the shared budget (the expansion this scan
+                    // belongs to is level one, hence >=) so over-deep chains surface a parse error.
+                    if (++expansions + this._nestingDepth >= MAX_SYNTAX_NESTING) {
+                        if (!reported) {
+                            this.errors.push({ message: "maximum arithmetic expansion nesting depth exceeded", pos: this.pos - 1 });
+                            reported = true;
+                        }
+                    }
+                    this.pos += 2;
+                }
+                else {
+                    parenDepth++;
+                    this.pos++;
+                }
+            }
+            else if (c === CH_RPAREN && parenDepth > 0) {
+                parenDepth--;
+                this.pos++;
+            }
+            else if (c === CH_RPAREN && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_RPAREN) {
+                if (--depth === 0) {
+                    this.pos += 2;
+                    break;
+                }
+                parenDepth = depth === 1 ? parentParenDepth : parenDepths.pop();
+                this.pos += 2;
+            }
+            else if (c === CH_RPAREN && depth === 1) {
+                // Bash reads `((` and `$((` as arithmetic only when the inner parenthesis pair is
+                // immediately followed by `)`. It closed without one, so `((a) )` is nested subshells
+                // and `$((a) || (b))` a command substitution; callers re-read from the start.
+                this._notArithmetic = true;
+                return "";
+            }
+            else {
+                this.pos++;
+            }
+        }
+        const bt = this._buildParts || this._buildValue;
+        if (depth > 0) {
+            this._arithUnterminated = true;
+            return bt ? src.slice(start, this.pos) : "";
+        }
+        return bt ? src.slice(start, this.pos - 2) : "";
+    }
+    readArithmeticExpansion(dollarPos) {
+        const bodyStart = this.pos + 2; // absolute offset of the body, past the "((" at this.pos
+        const body = this.scanArithmeticBody();
+        if (this._notArithmetic)
+            return;
+        if (this._arithUnterminated)
+            this.errors.push({ message: "unterminated arithmetic expansion", pos: dollarPos });
+        const text = this._buildParts || this._buildValue ? this.src.slice(dollarPos, this.pos) : "";
+        this._resultText = text;
+        this._resultIsRaw = true;
+        this._resultHasExpansion = false;
+        this._resultPart = this._buildParts
+            ? {
+                type: "ArithmeticExpansion",
+                pos: dollarPos,
+                end: this.pos,
+                text,
+                expression: this.buildArithmeticExpression(body, bodyStart),
+            }
+            : undefined;
+    }
+    // Pass the absolute body offset so arithmetic nodes index the original source directly
+    // (no re-basing). Nested $(...) command subs inside the arithmetic get an absolute
+    // innerStart so resolveCollected parses their window in place.
+    buildArithmeticExpression(body, bodyStart) {
+        if (!hasEmbeddedWordStructure(this.src, bodyStart, bodyStart + body.length)) {
+            return parseArithmeticExpression(body, bodyStart) ?? undefined;
+        }
+        const commandExpansions = [];
+        const embeddedWords = [];
+        const expr = parseArithmeticExpression(body, bodyStart, {
+            commandExpansions,
+            embeddedWords,
+            findClosingBracket: (start, end) => this.findClosingBracket(start, end),
+            findClosingBrace: (start, end) => this.findClosingBrace(start, end),
+            findClosingParenthesis: (start, end) => this.findClosingParenthesis(start, end),
+            findArithmeticExpansionEnd: (start, end) => this.findArithmeticExpansionEnd(start, end),
+            findArithmeticWordEnd: (start, end) => this.findArithmeticWordEnd(start, end),
+        }) ?? undefined;
+        for (const node of commandExpansions) {
+            this.collect(node, node.text.slice(2, -1), node.pos + 2, true);
+        }
+        for (const node of embeddedWords)
+            node.parts = this.parseSubFieldWord(node.pos, node.end).parts;
+        return expr;
+    }
+    readArithmeticCommand(out, tokenStart) {
+        const savedBuildValue = this._buildValue;
+        this._buildValue = true;
+        const body = this.scanArithmeticBody();
+        this._buildValue = savedBuildValue;
+        if (this._arithUnterminated)
+            this.errors.push({ message: "unterminated arithmetic command", pos: tokenStart });
+        setToken(out, Token.ArithCmd, body, tokenStart, this.pos);
+    }
+    readCommandSubstitution(dollarPos) {
+        const openPos = this.pos;
+        this.pos++; // skip (
+        // extractBalanced returns the inner text without the closing paren, so it
+        // stays correct when the input ended before that paren was reached.
+        const inner = this.extractBalanced();
+        if (this._unbalanced)
+            this.errors.push({ message: "unterminated command substitution", pos: dollarPos });
+        const bt = this._buildParts || this._buildValue;
+        const rawText = bt ? this.src.slice(dollarPos, this.pos) : "";
+        const text = !bt || openPos === dollarPos + 1 ? rawText : "$" + this.src.slice(openPos, this.pos);
+        this._resultText = text;
+        this._resultIsRaw = openPos === dollarPos + 1;
+        this._resultHasExpansion = true;
+        if (this._buildParts) {
+            this._resultPart = { type: "CommandExpansion", pos: dollarPos, end: this.pos, text: rawText, script: undefined };
+            this.collect(this._resultPart, inner, openPos + 1, !this._unbalanced);
+        }
+        else {
+            this._resultPart = undefined;
+        }
+    }
+    readBraceCommandSubstitution() {
+        this.readBraceSubstitution(1);
+    }
+    readValueSubstitution() {
+        this.readBraceSubstitution(2);
+    }
+    readBraceSubstitution(skip) {
+        const dollarPos = this.pos - 1;
+        this.pos += skip;
+        const src = this.src;
+        const len = this.srcEnd;
+        let depth = 1;
+        const start = this.pos;
+        while (this.pos < len) {
+            const c = src.charCodeAt(this.pos);
+            if (c === CH_LBRACE)
+                depth++;
+            else if (c === CH_RBRACE) {
+                if (--depth === 0) {
+                    this.pos++;
+                    break;
+                }
+            }
+            else if (c === CH_SQUOTE) {
+                this.pos++;
+                this.skipSQ();
+                continue;
+            }
+            else if (c === CH_DQUOTE) {
+                this.pos++;
+                this.skipDQ();
+                continue;
+            }
+            else if (c === CH_BACKSLASH)
+                this.pos++;
+            this.pos++;
+        }
+        this._resultIsRaw = true;
+        this._resultHasExpansion = true;
+        if (this._buildParts || this._buildValue) {
+            const rawInner = src.slice(start, this.pos - 1);
+            const inner = rawInner.trim();
+            const text = src.slice(dollarPos, this.pos);
+            this._resultText = text;
+            if (this._buildParts) {
+                const innerStart = start + (rawInner.length - rawInner.trimStart().length);
+                this._resultPart = { type: "CommandExpansion", pos: dollarPos, end: this.pos, text, script: undefined };
+                this.collect(this._resultPart, inner, innerStart);
+            }
+            else {
+                this._resultPart = undefined;
+            }
+        }
+        else {
+            this._resultText = "";
+            this._resultPart = undefined;
+        }
+    }
+    readBacktickExpansion(insideDoubleQuotes = false) {
+        this.pos++; // skip opening `
+        const src = this.src;
+        const len = this.srcEnd;
+        const start = this.pos;
+        if (!this._buildParts && !this._buildValue) {
+            while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+                if (src.charCodeAt(this.pos) === CH_BACKSLASH && this.pos + 1 < len)
+                    this.pos++;
+                this.pos++;
+            }
+            if (this.pos < len)
+                this.pos++;
+            else
+                this.errors.push({ message: "unterminated backtick", pos: start - 1 });
+            this._resultText = "";
+            this._resultIsRaw = false;
+            this._resultHasExpansion = true;
+            this._resultPart = undefined;
+            return;
+        }
+        let inner = "";
+        let hasEscapes = false;
+        while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+            if (src.charCodeAt(this.pos) === CH_BACKSLASH) {
+                hasEscapes = true;
+                break;
+            }
+            this.pos++;
+        }
+        if (!hasEscapes) {
+            inner = src.slice(start, this.pos);
+        }
+        else {
+            inner = src.slice(start, this.pos);
+            while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+                if (src.charCodeAt(this.pos) === CH_BACKSLASH) {
+                    this.pos++;
+                    if (this.pos < len) {
+                        const c = src.charCodeAt(this.pos);
+                        if (c === CH_DOLLAR || c === CH_BACKTICK || c === CH_BACKSLASH || (insideDoubleQuotes && c === CH_DQUOTE)) {
+                            inner += src[this.pos];
+                        }
+                        else {
+                            inner += "\\" + src[this.pos];
+                        }
+                        this.pos++;
+                    }
+                }
+                else {
+                    const runStart = this.pos;
+                    while (this.pos < len) {
+                        const c = src.charCodeAt(this.pos);
+                        if (c === CH_BACKTICK || c === CH_BACKSLASH)
+                            break;
+                        this.pos++;
+                    }
+                    inner += src.slice(runStart, this.pos);
+                }
+            }
+        }
+        if (this.pos < len)
+            this.pos++; // closing `
+        else
+            this.errors.push({ message: "unterminated backtick", pos: start - 1 });
+        const text = src.slice(start - 1, this.pos); // raw source including backticks
+        this._resultText = inner;
+        this._resultHasExpansion = true;
+        if (this._buildParts) {
+            // Escaped backticks rebuild `inner` (escapes removed), so its offsets no
+            // longer map linearly onto the source — leave innerStart undefined there.
+            this._resultPart = {
+                type: "CommandExpansion",
+                pos: start - 1,
+                end: this.pos,
+                text,
+                script: undefined,
+            };
+            this.collect(this._resultPart, inner, hasEscapes ? undefined : start);
+        }
+        else {
+            this._resultPart = undefined;
+        }
+    }
+    readParameterExpansion() {
+        const src = this.src;
+        const len = this.srcEnd;
+        const start = this.pos; // at {
+        this.pos++;
+        let depth = 1;
+        let reported = false;
+        while (this.pos < len && depth > 0) {
+            const ch = src.charCodeAt(this.pos);
+            if (ch === CH_DOLLAR) {
+                // Dispatch forward: `$$` consumes its own second `$`, so a `{` after it is literal.
+                const next = this.pos + 1 < len ? src.charCodeAt(this.pos + 1) : 0;
+                if (next === CH_LBRACE) {
+                    depth++;
+                    if (this._nestingDepth + depth > MAX_SYNTAX_NESTING && !reported) {
+                        this.errors.push({ message: "maximum parameter expansion nesting depth exceeded", pos: this.pos });
+                        reported = true;
+                    }
+                    this.pos += 2;
+                    continue;
+                }
+                if (next === CH_DOLLAR) {
+                    this.pos += 2;
+                    continue;
+                }
+                if (next === CH_LPAREN) {
+                    const dollarPos = this.pos;
+                    this.pos += 2;
+                    this.extractBalanced();
+                    if (this._unbalanced)
+                        this.errors.push({ message: "unterminated command substitution", pos: dollarPos });
+                    continue;
+                }
+            }
+            else if (ch === CH_BACKTICK) {
+                this.pos++;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+                    if (src.charCodeAt(this.pos) === CH_BACKSLASH)
+                        this.pos++;
+                    this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+                continue;
+            }
+            else if (ch === CH_RBRACE) {
+                if (--depth === 0) {
+                    this.pos++;
+                    break;
+                }
+            }
+            else if (ch === CH_BACKSLASH) {
+                if (this.pos + 1 < len)
+                    this.pos++;
+            }
+            else if (ch === CH_SQUOTE) {
+                this.pos++;
+                if (this.pos > start + 1 && src.charCodeAt(this.pos - 2) === CH_DOLLAR)
+                    this.skipAnsiCQuoted();
+                else
+                    this.skipSQ();
+                continue;
+            }
+            else if (ch === CH_DQUOTE) {
+                this.pos++;
+                this.skipDQ();
+                continue;
+            }
+            this.pos++;
+        }
+        const closed = depth === 0;
+        if (!closed)
+            this.errors.push({ message: "unterminated parameter expansion", pos: start - 1 });
+        const text = this._buildParts || this._buildValue ? src.slice(start - 1, this.pos) : "";
+        this._resultText = text;
+        this._resultIsRaw = true;
+        this._resultHasExpansion = false;
+        if (this._buildParts) {
+            const inner = src.slice(start + 1, closed ? this.pos - 1 : this.pos);
+            this._resultPart = this.parseParamInner(text, inner, start + 1);
+        }
+        else {
+            this._resultPart = undefined;
+        }
+    }
+    // `innerStart` is the absolute offset of `inner` in the original source, so each sub-field
+    // word is parsed in place at its true position. `sub(a, b)` maps inner-relative offsets to
+    // that absolute window.
+    parseParamInner(text, inner, innerStart) {
+        const result = {
+            type: "ParameterExpansion",
+            pos: innerStart - 2,
+            end: this.pos,
+            text,
+            parameter: "",
+            parameterPos: innerStart,
+            parameterEnd: innerStart,
+            prefix: undefined,
+            index: undefined,
+            operation: undefined,
+        };
+        const ilen = inner.length;
+        if (ilen === 0)
+            return result;
+        const sub = (a, b) => this.parseSubFieldWord(innerStart + a, innerStart + b);
+        const closeBracket = (start) => {
+            const close = this.findClosingBracket(innerStart + start, innerStart + ilen);
+            return close === -1 ? -1 : close - innerStart;
+        };
+        let i = 0;
+        if (ilen > 1 && inner.charCodeAt(0) === CH_BANG) {
+            result.prefix = "!";
+            i = 1;
+        }
+        if (ilen > 1 && inner.charCodeAt(0) === CH_HASH) {
+            const nameEnd = this.scanParamName(inner, 1);
+            let parameterEnd = nameEnd;
+            let indexEnd = -1;
+            if (parameterEnd < ilen && inner.charCodeAt(parameterEnd) === CH_LBRACKET) {
+                indexEnd = closeBracket(parameterEnd + 1);
+                if (indexEnd !== -1)
+                    parameterEnd = indexEnd + 1;
+            }
+            if (nameEnd > 1 && parameterEnd === ilen) {
+                result.prefix = "#";
+                result.parameter = inner.slice(1, nameEnd);
+                result.parameterPos = innerStart + 1;
+                result.parameterEnd = innerStart + nameEnd;
+                if (indexEnd !== -1)
+                    result.index = sub(nameEnd + 1, indexEnd);
+                return result;
+            }
+        }
+        const nameStart = i;
+        i = this.scanParamName(inner, i);
+        result.parameter = inner.slice(nameStart, i);
+        result.parameterPos = innerStart + nameStart;
+        result.parameterEnd = innerStart + i;
+        if (i < ilen && inner.charCodeAt(i) === CH_LBRACKET) {
+            const closeB = closeBracket(i + 1);
+            if (closeB !== -1) {
+                result.index = sub(i + 1, closeB);
+                i = closeB + 1;
+            }
+        }
+        if (i >= ilen)
+            return result;
+        const pos = innerStart + i;
+        const end = innerStart + ilen;
+        const opChar = inner.charCodeAt(i);
+        const nextChar = inner.charCodeAt(i + 1);
+        const defaultChar = inner[opChar === CH_COLON ? i + 1 : i];
+        if (defaultChar === "-" || defaultChar === "=" || defaultChar === "+" || defaultChar === "?") {
+            const operandStart = i + (opChar === CH_COLON ? 2 : 1);
+            result.operation = {
+                type: "Default",
+                pos,
+                end,
+                operatorEnd: innerStart + operandStart,
+                operator: opChar === CH_COLON ? `:${defaultChar}` : defaultChar,
+                operand: sub(operandStart, ilen),
+            };
+            return result;
+        }
+        if (opChar === CH_COLON) {
+            i++;
+            const sliceStart = innerStart + i;
+            const colonIdx = findUnnested(inner.slice(i), CH_COLON, true, (index, quoted) => {
+                return this.findNestedShellEnd(sliceStart + index, end, quoted) - sliceStart;
+            });
+            result.operation = {
+                type: "Slice",
+                pos,
+                end,
+                operatorEnd: sliceStart,
+                operator: ":",
+                offset: sub(i, colonIdx === -1 ? ilen : i + colonIdx),
+                length: colonIdx === -1 ? undefined : sub(i + colonIdx + 1, ilen),
+            };
+            return result;
+        }
+        if (opChar === CH_HASH || opChar === CH_PERCENT) {
+            const doubled = nextChar === opChar;
+            const operator = opChar === CH_HASH ? (doubled ? "##" : "#") : doubled ? "%%" : "%";
+            const operandStart = i + (doubled ? 2 : 1);
+            result.operation = {
+                type: "Remove",
+                pos,
+                end,
+                operatorEnd: innerStart + operandStart,
+                operator,
+                operand: sub(operandStart, ilen),
+            };
+            return result;
+        }
+        if (opChar === CH_SLASH) {
+            i++;
+            let operator = "/";
+            if (nextChar === CH_SLASH || nextChar === CH_HASH || nextChar === CH_PERCENT) {
+                operator = nextChar === CH_SLASH ? "//" : nextChar === CH_HASH ? "/#" : "/%";
+                i++;
+            }
+            let separatorStart = i;
+            if (nextChar === CH_SLASH) {
+                // After // a leading slash belongs to the pattern; /# and /% allow empty patterns.
+                separatorStart = skipLineContinuations(inner, i, ilen);
+                if (inner.charCodeAt(separatorStart) === CH_SLASH)
+                    separatorStart++;
+            }
+            const sepIdx = findUnnested(inner.slice(separatorStart), CH_SLASH);
+            const patternEnd = sepIdx === -1 ? ilen : separatorStart + sepIdx;
+            result.operation = {
+                type: "Replace",
+                pos,
+                end,
+                operatorEnd: innerStart + i,
+                operator,
+                pattern: sub(i, patternEnd),
+                replacement: sub(sepIdx === -1 ? ilen : patternEnd + 1, ilen),
+            };
+            return result;
+        }
+        if (opChar === CH_CARET || opChar === CH_COMMA) {
+            const doubled = nextChar === opChar;
+            const operator = opChar === CH_CARET ? (doubled ? "^^" : "^") : doubled ? ",," : ",";
+            const operandStart = i + (doubled ? 2 : 1);
+            result.operation = {
+                type: "CaseModification",
+                pos,
+                end,
+                operatorEnd: innerStart + operandStart,
+                operator,
+                operand: operandStart === ilen ? undefined : sub(operandStart, ilen),
+            };
+            return result;
+        }
+        if (result.prefix === "!" &&
+            result.index === undefined &&
+            i + 1 === ilen &&
+            (opChar === CH_AT || opChar === CH_STAR)) {
+            result.operation = { type: "Names", pos, end, operatorEnd: end, operator: opChar === CH_AT ? "@" : "*" };
+            return result;
+        }
+        if (opChar === CH_AT) {
+            result.operation = {
+                type: "Transform",
+                pos,
+                end,
+                operatorEnd: pos + 1,
+                operator: "@",
+                operand: sub(i + 1, ilen),
+            };
+            return result;
+        }
+        result.operation = { type: "Unknown", pos, end, operatorEnd: end, operator: inner.slice(i) };
+        return result;
+    }
+    findNestedShellEnd(start, end, quoted) {
+        const ch = this.src.charCodeAt(start);
+        if (ch === CH_BACKTICK) {
+            let pos = start + 1;
+            while (pos < end) {
+                const current = this.src.charCodeAt(pos);
+                if (current === CH_BACKSLASH) {
+                    pos += 2;
+                    continue;
+                }
+                pos++;
+                if (current === CH_BACKTICK)
+                    return pos;
+            }
+            return end;
+        }
+        let close;
+        if (ch === CH_DOLLAR) {
+            const next = start + 1;
+            if (next < end && this.src.charCodeAt(next) === CH_LBRACE) {
+                close = this.findClosingBrace(next + 1, end);
+            }
+            else {
+                const open = skipLineContinuations(this.src, next, end);
+                if (open >= end || this.src.charCodeAt(open) !== CH_LPAREN)
+                    return start;
+                close = this.findClosingParenthesis(open + 1, end);
+            }
+        }
+        else {
+            const open = start + 1;
+            if (quoted || (ch !== CH_LT && ch !== CH_GT) || open >= end || this.src.charCodeAt(open) !== CH_LPAREN) {
+                return start;
+            }
+            close = this.findClosingParenthesis(open + 1, end);
+        }
+        return close === -1 ? end : close + 1;
+    }
+    scanParamName(s, start) {
+        let i = start;
+        if (i >= s.length)
+            return i;
+        const c = s.charCodeAt(i);
+        // Special single-char params
+        if (c === CH_AT ||
+            c === CH_STAR ||
+            c === CH_HASH ||
+            c === CH_QUESTION ||
+            c === CH_DASH ||
+            c === CH_DOLLAR ||
+            c === CH_BANG) {
+            return i + 1;
+        }
+        // Digits
+        if (c >= CH_0 && c <= CH_9) {
+            while (i < s.length && s.charCodeAt(i) >= CH_0 && s.charCodeAt(i) <= CH_9)
+                i++;
+            return i;
+        }
+        // Regular name: [a-zA-Z_][a-zA-Z0-9_]*
+        if ((c >= CH_a && c <= CH_z) || (c >= CH_A && c <= CH_Z) || c === CH_UNDERSCORE) {
+            i++;
+            while (i < s.length) {
+                const ch = s.charCodeAt(i);
+                if ((ch >= CH_a && ch <= CH_z) ||
+                    (ch >= CH_A && ch <= CH_Z) ||
+                    (ch >= CH_0 && ch <= CH_9) ||
+                    ch === CH_UNDERSCORE)
+                    i++;
+                else
+                    break;
+            }
+        }
+        return i;
+    }
+    readAnsiCQuoted() {
+        const quotePos = this.pos - 1;
+        const result = decodeAnsiCQuoted(this.src, this.pos, this.srcEnd);
+        this.pos = result.end;
+        if (!result.closed)
+            this.errors.push({ message: "unterminated ANSI-C quote", pos: quotePos });
+        return result.value;
+    }
+    // Extract balanced parens for $(...) — respects nested quotes and case..esac
+    extractBalanced() {
+        const src = this.src;
+        const len = this.srcEnd;
+        const bt = this._buildParts || this._buildValue;
+        let depth = 1;
+        const start = this.pos;
+        this._unbalanced = false;
+        let wordStart = true;
+        // Fast path: scan for simple cases with no nested quotes/parens/case. Nothing here
+        // opens a paren — `(` breaks to the slow path — so depth stays 1 and the first `)`
+        // closes the construct.
+        while (this.pos < len) {
+            const c = src.charCodeAt(this.pos);
+            if (c === CH_RPAREN) {
+                const result = bt ? src.slice(start, this.pos) : "";
+                this.pos++;
+                return result;
+            }
+            else if (c === CH_LPAREN || c === CH_BACKSLASH || c === CH_SQUOTE || c === CH_DQUOTE || c === CH_BACKTICK) {
+                break;
+            }
+            else if (c === CH_LT && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LT) {
+                break;
+            }
+            else if (c === CH_HASH && wordStart) {
+                break;
+            }
+            else if (c === 99 /* c */ &&
+                wordStart &&
+                this.pos + 3 < len &&
+                src.charCodeAt(this.pos + 1) === 97 /* a */ &&
+                src.charCodeAt(this.pos + 2) === 115 /* s */ &&
+                src.charCodeAt(this.pos + 3) === 101 /* e */ &&
+                (this.pos + 4 >= len || (src.charCodeAt(this.pos + 4) < 128 && charType[src.charCodeAt(this.pos + 4)] & 1))) {
+                break;
+            }
+            else {
+                wordStart = c < 128 && (charType[c] & 1) !== 0;
+                this.pos++;
+            }
+        }
+        // Slow path: just track position (source is copied verbatim, so slice at end)
+        let caseDepth = 0;
+        // Parentheses opened since the innermost `case` began. A `)` only terminates a case
+        // pattern when nothing is open — otherwise it closes a pattern's leading `(`, an
+        // extglob group, or a subshell in the case body, and must rebalance `depth`.
+        let caseParens = 0;
+        // Word-form parens resume mid-word; grammar parens resume where `#` can open a comment.
+        const wordStartAfterParen = [];
+        let pendingDelims = null;
+        let arithBase = -1;
+        // A `$((` extent is found by bash's arithmetic scanner, where `#` is ordinary, and keeps
+        // that extent even for a command body. The two chars before `start` are the delimiter.
+        const arithExtent = start >= 2 &&
+            src.charCodeAt(start) === CH_LPAREN &&
+            src.charCodeAt(start - 1) === CH_LPAREN &&
+            src.charCodeAt(start - 2) === CH_DOLLAR;
+        let substitutions = 0;
+        let reported = false;
+        let continuedDollarPos = -1;
+        let continuedParenPos = -1;
+        while (this.pos < len && depth > 0) {
+            const ch = src.charCodeAt(this.pos);
+            if (ch === CH_LPAREN) {
+                const prev = this.pos > start ? src.charCodeAt(this.pos - 1) : 0;
+                const commandDollarPos = prev === CH_DOLLAR ? this.pos - 1 : this.pos === continuedParenPos ? continuedDollarPos : -1;
+                const wordParen = commandDollarPos !== -1 ||
+                    prev === CH_LT ||
+                    prev === CH_GT ||
+                    prev === CH_EQ ||
+                    prev === CH_AT ||
+                    prev === CH_QUESTION ||
+                    prev === CH_STAR ||
+                    prev === CH_PLUS ||
+                    prev === CH_BANG ||
+                    (prev === CH_LPAREN && wordStartAfterParen[wordStartAfterParen.length - 1] === false) ||
+                    (arithExtent && this.pos === start);
+                wordStartAfterParen.push(!wordParen);
+                wordStart = true;
+                // (( opens arithmetic — suppress heredoc detection until the parens
+                // rebalance so shift operators inside aren't mistaken for heredocs
+                if (arithBase < 0 && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+                    arithBase = depth;
+                }
+                // Nested $( — count it against the shared budget (the substitution being
+                // scanned is level one, hence >=) so over-deep chains surface a parse error.
+                if (commandDollarPos !== -1 && ++substitutions + this._nestingDepth >= MAX_SYNTAX_NESTING) {
+                    if (!reported) {
+                        this.errors.push({ message: "maximum command substitution nesting depth exceeded", pos: commandDollarPos });
+                        reported = true;
+                    }
+                }
+                continuedDollarPos = -1;
+                continuedParenPos = -1;
+                depth++;
+                if (caseDepth > 0)
+                    caseParens++;
+                this.pos++;
+            }
+            else if (ch === CH_RPAREN) {
+                if (caseDepth > 0 && caseParens === 0) {
+                    this.pos++;
+                    wordStart = true;
+                }
+                else {
+                    if (caseDepth > 0)
+                        caseParens--;
+                    depth--;
+                    if (depth === 0) {
+                        const result = bt ? src.slice(start, this.pos) : "";
+                        this.pos++;
+                        return result;
+                    }
+                    if (depth <= arithBase)
+                        arithBase = -1;
+                    wordStart = wordStartAfterParen.pop() ?? true;
+                    this.pos++;
+                }
+            }
+            else if (ch === CH_BACKSLASH) {
+                if (this.pos > start && src.charCodeAt(this.pos - 1) === CH_DOLLAR) {
+                    const logicalPos = skipLineContinuations(src, this.pos, len);
+                    if (logicalPos > this.pos &&
+                        src.charCodeAt(logicalPos) === CH_LPAREN &&
+                        src.charCodeAt(logicalPos + 1) !== CH_LPAREN) {
+                        continuedDollarPos = this.pos - 1;
+                        continuedParenPos = logicalPos;
+                    }
+                }
+                this.pos++;
+                if (this.pos < len) {
+                    if (src.charCodeAt(this.pos) !== CH_NL) {
+                        wordStart = false;
+                    }
+                    this.pos++;
+                }
+            }
+            else if (ch === CH_SQUOTE) {
+                this.pos++;
+                this.skipSQ();
+                wordStart = false;
+            }
+            else if (ch === CH_DQUOTE) {
+                this.pos++;
+                this.skipDQ();
+                wordStart = false;
+            }
+            else if (ch === CH_BACKTICK) {
+                this.pos++;
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_BACKTICK) {
+                    if (src.charCodeAt(this.pos) === CH_BACKSLASH)
+                        this.pos++;
+                    if (this.pos < len)
+                        this.pos++;
+                }
+                if (this.pos < len)
+                    this.pos++;
+                wordStart = false;
+            }
+            else if (ch === CH_LT && arithBase < 0 && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LT) {
+                // << is a heredoc operator even in case-pattern position — unquoted <<
+                // inside a pattern is a bash syntax error, so no caseDepth gate here
+                if (this.pos + 2 < len && src.charCodeAt(this.pos + 2) === CH_LT) {
+                    this.pos += 3; // <<< herestring
+                }
+                else {
+                    this.pos += 2;
+                    const strip = this.pos < len && src.charCodeAt(this.pos) === CH_DASH;
+                    if (strip)
+                        this.pos++;
+                    this.skipSpacesAndTabs();
+                    this.readHereDocDelimiter();
+                    // Empty unquoted delimiter means there was no delimiter word (`<< )`)
+                    if (this._hereDelim || this._hereQuoted) {
+                        (pendingDelims ?? (pendingDelims = [])).push({
+                            delimiter: this._hereDelim,
+                            strip,
+                            quoted: this._hereQuoted,
+                        });
+                    }
+                }
+                wordStart = false;
+            }
+            else if (ch === CH_NL && pendingDelims) {
+                this.pos++;
+                for (const hd of pendingDelims)
+                    this.skipHereDocBody(hd.delimiter, hd.strip, true, hd.quoted);
+                pendingDelims = null;
+                wordStart = true;
+            }
+            else if (ch === CH_HASH && arithBase < 0 && !arithExtent && wordStart) {
+                // Word-boundary # opens a comment — opaque up to (not including) the
+                // newline, so quotes and << inside it stay inert
+                while (this.pos < len && src.charCodeAt(this.pos) !== CH_NL)
+                    this.pos++;
+            }
+            else {
+                const wStart = this.pos;
+                while (this.pos < len) {
+                    const wc = src.charCodeAt(this.pos);
+                    if (wc < 128 && charType[wc])
+                        break;
+                    this.pos++;
+                }
+                if (this.pos > wStart) {
+                    const wLen = this.pos - wStart;
+                    if (wLen === 4 && wordStart) {
+                        const c0 = src.charCodeAt(wStart);
+                        if (c0 === 99 &&
+                            src.charCodeAt(wStart + 1) === 97 &&
+                            src.charCodeAt(wStart + 2) === 115 &&
+                            src.charCodeAt(wStart + 3) === 101) {
+                            caseDepth++;
+                        }
+                        else if (c0 === 101 &&
+                            src.charCodeAt(wStart + 1) === 115 &&
+                            src.charCodeAt(wStart + 2) === 97 &&
+                            src.charCodeAt(wStart + 3) === 99 &&
+                            caseDepth > 0) {
+                            caseDepth--;
+                            if (caseDepth === 0)
+                                caseParens = 0;
+                        }
+                    }
+                    wordStart = false;
+                }
+                else {
+                    const wc = src.charCodeAt(this.pos);
+                    wordStart = wc < 128 && (charType[wc] & 1) !== 0;
+                    this.pos++;
+                }
+            }
+        }
+        // Ran out of input before the closing paren.
+        this._unbalanced = true;
+        return bt ? src.slice(start, this.pos) : "";
+    }
+}