@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/src/vendor/unbash/lexer.ts

@@ -0,0 +1,4352 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+// oxlint-disable unicorn/no-thenable
+import type {
+  DoubleQuotedChild,
+  ExtGlobOperator,
+  HereDoc,
+  ParameterExpansionPart,
+  ParseError,
+  Word,
+  WordPart,
+} from "./internal-types.ts";
+import { decodeAnsiCQuoted } from "./ansi-c.ts";
+import {
+  ArithmeticExpansionImpl,
+  ProcessSubstitutionImpl,
+  ScriptExpansionImpl,
+  type ScriptWindow,
+} from "./expansion.ts";
+import { MAX_SYNTAX_NESTING } from "./limits.ts";
+import { WordImpl } from "./word.ts";
+import { createSubstitutionContext, type SubstitutionContext } from "./substitution-context.ts";
+import { hasGlobCharacters, parseGlobParts } from "./glob.ts";
+import {
+  skipLineContinuations,
+  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.ts";
+
+type SubFieldContext = "word" | "quoted" | "embedded";
+
+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,
+} as const;
+
+export type Token = (typeof Token)[keyof typeof Token];
+
+export class TokenValue {
+  token: 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: string | null = "";
+  _owner: Lexer | null;
+  pos: number = 0;
+  end: number = 0;
+  fileDescriptor: number | undefined = undefined;
+  variableName: string | undefined = undefined;
+  descriptorEnd = 0;
+  delimiterQuoted = false;
+  content: string | undefined = 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: Lexer | null = null) {
+    this._owner = owner;
+  }
+
+  get value(): string {
+    return (
+      this._value ?? (this._value = this._owner === null ? "" : this._owner._tokenValue(this.pos, this.end, this.raw))
+    );
+  }
+  set value(v: string) {
+    this._value = v;
+  }
+
+  reset(): void {
+    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: TokenValue): void {
+    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<string, Token>([
+  ["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: string): boolean {
+  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;
+
+function skipBlanks(source: string, pos: number, end: number): number {
+  while (pos < end) {
+    const ch = source.charCodeAt(pos);
+    if (ch === CH_SPACE || ch === CH_TAB) pos++;
+    else if (ch === CH_BACKSLASH && pos + 1 < end && source.charCodeAt(pos + 1) === CH_NL) pos += 2;
+    else break;
+  }
+  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: string, start: number, end: number): boolean {
+  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: string,
+  target: number,
+  pairTernaries = false,
+  findNestedEnd?: (index: number, quoted: boolean) => number,
+): number {
+  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;
+
+// `=(` opens an array value, not a pattern.
+function isExtglobOpen(prefix: number): boolean {
+  return prefix < 128 && prefix !== CH_EQ && extglobPrefix[prefix] === 1;
+}
+
+const extglobOp: Record<number, ExtGlobOperator> = {
+  [CH_QUESTION]: "?",
+  [CH_AT]: "@",
+  [CH_STAR]: "*",
+  [CH_PLUS]: "+",
+  [CH_BANG]: "!",
+};
+
+function isDQChild(p: WordPart): p is DoubleQuotedChild {
+  const t = p.type;
+  return (
+    t === "Literal" ||
+    t === "SimpleExpansion" ||
+    t === "ParameterExpansion" ||
+    t === "CommandExpansion" ||
+    t === "ArithmeticExpansion"
+  );
+}
+
+function isAllDigitsRange(src: string, start: number, end: number): boolean {
+  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 joinWordParts(head: WordPart[], tail: WordPart[]): WordPart[] {
+  const last = head[head.length - 1];
+  const first = tail[0];
+  let start = 0;
+  if (last?.type === "Literal" && first?.type === "Literal" && last.end === first.pos) {
+    head[head.length - 1] = {
+      type: "Literal",
+      pos: last.pos,
+      end: first.end,
+      text: last.text + first.text,
+      value: last.value + first.value,
+    };
+    start = 1;
+  }
+  for (let i = start; i < tail.length; i++) head.push(tail[i]);
+  return head;
+}
+
+function isMatchedAssignment(state: number): boolean {
+  return state < ASSIGNMENT_INVALID;
+}
+
+function assignmentOperatorPos(state: number): number {
+  return -state - 2;
+}
+
+function scanAssignmentPrefix(src: string, start: number, end: number, initialState: number): number {
+  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;
+}
+
+interface PendingHereDoc {
+  delimiter: string;
+  strip: boolean;
+  quoted: boolean;
+  target?: HereDoc;
+}
+
+function setToken(out: TokenValue, token: Token, value: string, pos: number = 0, end: number = 0): void {
+  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: TokenValue, token: Token, pos: number, end: number, raw: boolean): void {
+  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: string, start: number, len: number): Token | undefined {
+  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,
+  FunctionName: 6,
+  CasePattern: 7,
+  // Arguments of eval and let: ordinary words, but `name=(…)` keeps its array value as in Bash.
+  EvalArgument: 8,
+} as const;
+export type LexContext = (typeof LexContext)[keyof typeof LexContext];
+
+export class Lexer {
+  static _findSubstitutionEnd:
+    | ((source: string, start: number, end: number, depth: number, context: SubstitutionContext) => number)
+    | undefined;
+  private src: string;
+  private srcEnd: number;
+  private parenBoundary: boolean;
+  private pos: number;
+  private current: TokenValue;
+  private nextState: TokenValue;
+  private hasPeek: boolean;
+  private pendingHereDocs: PendingHereDoc[] | null;
+  private substitutionContext: SubstitutionContext;
+  _errors: ParseError[] | null = 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: string,
+    start = 0,
+    end = src.length,
+    parenBoundary = false,
+    context: SubstitutionContext = createSubstitutionContext(),
+  ) {
+    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.substitutionContext = context;
+
+    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(): string {
+    return this.src;
+  }
+
+  // Fresh window sharing source, depth and substitution context; tokens, errors, heredocs and build flags reset.
+  fork(start: number, end: number, parenBoundary = false): Lexer {
+    const lexer = new Lexer(this.src, start, end, parenBoundary, this.substitutionContext);
+    lexer._nestingDepth = this._nestingDepth;
+    return lexer;
+  }
+
+  getSubstitutionContext(): SubstitutionContext {
+    return this.substitutionContext;
+  }
+
+  get errors(): ParseError[] {
+    return this._errors ?? (this._errors = []);
+  }
+
+  // A substitution's script parses lazily, one level below the window it was found in, in
+  // place over `inner` at `start`, sharing this scan's substitution boundaries.
+  private commandExpansion(
+    pos: number,
+    text: string,
+    start: number,
+    inner: string,
+    parenBoundary = false,
+  ): ScriptExpansionImpl<"CommandExpansion"> {
+    const window = this.scriptWindow(this.src, start, start + inner.length, parenBoundary);
+    return new ScriptExpansionImpl("CommandExpansion", pos, this.pos, text, window);
+  }
+
+  // Escaped backticks rebuild `inner` with the escapes removed, so it is no longer a verbatim
+  // substring of the source: that script parses the decoded body as its own source.
+  private decodedCommandExpansion(pos: number, text: string, inner: string): ScriptExpansionImpl<"CommandExpansion"> {
+    const window = this.scriptWindow(inner, 0, inner.length, false, true);
+    return new ScriptExpansionImpl("CommandExpansion", pos, this.pos, text, window);
+  }
+
+  private processSubstitution(pos: number, text: string, operator: "<" | ">", inner: string): ProcessSubstitutionImpl {
+    const window = this.scriptWindow(this.src, pos + 2, pos + 2 + inner.length, !this._unbalanced);
+    return new ProcessSubstitutionImpl(pos, this.pos, text, operator, window);
+  }
+
+  // Past the nesting budget the part gets no window, so lazy materialization bottoms out.
+  private scriptWindow(
+    source: string,
+    start: number,
+    end: number,
+    parenBoundary: boolean,
+    decoded = false,
+  ): ScriptWindow | undefined {
+    if (this._nestingDepth > MAX_SYNTAX_NESTING) return undefined;
+    const context = decoded ? undefined : this.substitutionContext;
+    return { source, start, end, depth: this._nestingDepth + 1, parenBoundary, context };
+  }
+
+  getPos(): number {
+    return this.pos;
+  }
+
+  protected findSubstitutionEnd(start: number, end: number, depth = this._nestingDepth + 1): number {
+    if (Lexer._findSubstitutionEnd === undefined) return -1;
+    return Lexer._findSubstitutionEnd(this.src, start, end, depth, this.substitutionContext);
+  }
+
+  /** Materialize a word token's value: raw spans slice directly, others re-lex the span. */
+  _tokenValue(pos: number, end: number, raw: boolean): string {
+    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.
+  private wordValueOf(start: number, end: number): string {
+    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();
+    if (
+      this.pos < end &&
+      this._wordAssignmentState !== undefined &&
+      this._wordAssignmentState >= ASSIGNMENT_INDEX_BASE
+    ) {
+      this.pos = start;
+      this.readWordText(true);
+    }
+    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: number, end: number = this.srcEnd): number {
+    // A failed search scans to the end and every unclosed subscript at a command position
+    // retries it, so answer from the last bracket in the window first.
+    const limit = Math.min(end, this.srcEnd);
+    let window = this._bracketWindow;
+    if (!window || window.limit !== limit) {
+      window = { limit, last: this.src.lastIndexOf("]", limit - 1) };
+      this._bracketWindow = window;
+    }
+    if (start > window.last) return -1;
+    return this.findClosingShellDelimiter(start, end, CH_RBRACKET);
+  }
+
+  /** Find the closing bracket of `$[ … ]`, which unlike a subscript does not recurse into `${ }`. */
+  private findClosingArithmeticBracket(start: number, end: number = this.srcEnd): number {
+    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: number, end: number = this.srcEnd): number {
+    return this.findClosingShellDelimiter(start, end, CH_RBRACE);
+  }
+
+  /** Find the closing parenthesis for a shell substitution using the command-aware scanner. */
+  findClosingParenthesis(start: number, end: number = this.srcEnd): number {
+    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: number, end: number = this.srcEnd): number {
+    const scanner = this.fork(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: number, end: number = this.srcEnd): number {
+    const scanner = this.fork(start, end);
+    scanner.pos = start;
+    return scanner.scanArithmeticWordEnd();
+  }
+
+  private scanArithmeticWordEnd(): number {
+    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 and leading `[` subscripts and reject operators;
+  // extglob shares this scanner, and `#` is pattern data there.
+  private findClosingShellDelimiter(start: number, end: number, closing: number, array = false, braces = true): number {
+    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;
+    let invalid = -1;
+
+    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 && array && 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_SQUOTE) {
+          pos = decodeAnsiCQuoted(this.src, pos + 2, this.srcEnd).end;
+          wordStart = false;
+          continue;
+        }
+        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 (array && delimiters.length === 1) {
+        if (ch === CH_LBRACKET && wordStart) {
+          delimiters.push(CH_RBRACKET);
+        } else if (
+          invalid === -1 &&
+          (ch === CH_SEMI ||
+            ch === CH_AMP ||
+            ch === CH_PIPE ||
+            ch === CH_LT ||
+            ch === CH_GT ||
+            (ch === CH_LPAREN && !isExtglobOpen(this.src.charCodeAt(pos - 1))))
+        ) {
+          invalid = pos;
+        }
+      }
+      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;
+          if (invalid !== -1)
+            this.errors.push({ message: `unexpected '${this.src[invalid]}' in array assignment`, pos: invalid });
+          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;
+  }
+
+  // End of the brace expansion opened at `start`, or -1. As in Bash's brace_gobbler, quotes,
+  // escapes, parameter expansions and substitutions are opaque; an unquoted metacharacter
+  // ends the word before the brace closes. The word scan reports errors in the skipped text.
+  private scanBraceExpansion(start: number): number {
+    const src = this.src;
+    const len = this.srcEnd;
+    const first = start + 1 < len ? src.charCodeAt(start + 1) : 0;
+    if (first <= CH_SPACE || first === CH_RBRACE) return -1;
+    const savedPos = this.pos;
+    const savedUnbalanced = this._unbalanced;
+    const errorCount = this._errors === null ? 0 : this._errors.length;
+    let depth = 1;
+    let hasSep = false;
+    let end = -1;
+    let pos = start + 1;
+    while (pos < len) {
+      const ch = src.charCodeAt(pos);
+      const type = ch < 128 ? charType[ch] : 0;
+      if (type === 0) {
+        pos++;
+        if (ch === CH_RBRACE) {
+          if (--depth === 0) {
+            end = pos;
+            break;
+          }
+        } else if (depth === 1 && (ch === 0x2c /* , */ || (ch === 0x2e /* . */ && src.charCodeAt(pos) === 0x2e))) {
+          hasSep = true;
+        }
+        continue;
+      }
+      const next = pos + 1 < len ? src.charCodeAt(pos + 1) : 0;
+      if (type & 1) {
+        if (next === CH_LPAREN && (ch === CH_LT || ch === CH_GT)) {
+          this.pos = pos + 2;
+          this.extractBalanced();
+          pos = this.pos;
+        } else if (ch === CH_LPAREN && isExtglobOpen(src.charCodeAt(pos - 1))) {
+          const close = this.findClosingShellDelimiter(pos + 1, len, CH_RPAREN);
+          if (close === -1) break;
+          pos = close + 1;
+        } else {
+          break;
+        }
+      } else if (ch === CH_BACKSLASH) {
+        pos += 2;
+      } else if (ch === CH_SQUOTE) {
+        this.pos = pos + 1;
+        this.skipSQ();
+        pos = this.pos;
+      } else if (ch === CH_DQUOTE) {
+        this.pos = pos + 1;
+        this.skipDQ();
+        pos = this.pos;
+      } else if (ch === CH_BACKTICK) {
+        pos++;
+        while (pos < len && src.charCodeAt(pos) !== CH_BACKTICK) pos += src.charCodeAt(pos) === CH_BACKSLASH ? 2 : 1;
+        pos++;
+      } else if (ch === CH_LBRACE) {
+        depth++;
+        pos++;
+      } else if (next === CH_SQUOTE) {
+        pos = decodeAnsiCQuoted(src, pos + 2, len).end;
+      } else if (next === CH_LBRACE) {
+        const close = this.findClosingBrace(pos + 2, len);
+        if (close === -1) break;
+        pos = close + 1;
+      } else if (next === CH_LPAREN) {
+        this.pos = pos + 2;
+        this.extractBalanced();
+        pos = this.pos;
+      } else {
+        pos++;
+      }
+    }
+    this.pos = savedPos;
+    this._unbalanced = savedUnbalanced;
+    if (this._errors !== null) this._errors.length = errorCount;
+    return hasSep ? end : -1;
+  }
+
+  skipSubshellBody(): number {
+    this.extractBalanced(false);
+    return this._unbalanced ? -1 : this.pos;
+  }
+
+  skipCompoundBody(closeToken: Token): number {
+    type RecoveryPhase =
+      | "commands"
+      | "for-header"
+      | "case-word"
+      | "case-in"
+      | "case-pattern"
+      | "function-name"
+      | "function-body"
+      | "coproc-command"
+      | "coproc-body"
+      | "time-command"
+      | "time-command-after-p";
+    type RecoveryFrame = { close: Token; phase: RecoveryPhase };
+
+    const frames: RecoveryFrame[] = [
+      { close: closeToken, phase: closeToken === Token.Esac ? "case-pattern" : "commands" },
+    ];
+    let commandStart = true;
+
+    for (;;) {
+      const phase = frames[frames.length - 1].phase;
+      let ctx: LexContext = commandStart ? LexContext.CommandStart : LexContext.Normal;
+      if (phase === "function-name") ctx = LexContext.FunctionName;
+      else if (phase === "case-pattern" && commandStart) ctx = LexContext.CasePattern;
+      const value = this.next(ctx);
+      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(): number {
+    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;
+    }
+  }
+
+  private skipTestCommandBody(): boolean {
+    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: number): WordPart[] | null {
+    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();
+      const text = this.src.slice(startPos, this.pos);
+      const part = this.processSubstitution(startPos, text, ch === 0x3c ? "<" : ">", inner);
+      // 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();
+      // A command word whose subscript holds a blank was bounded by the matched-pair rescan, so
+      // its parts need the same scan.
+      if (
+        this.pos < this.srcEnd &&
+        this._wordAssignmentState !== undefined &&
+        this._wordAssignmentState >= ASSIGNMENT_INDEX_BASE
+      ) {
+        this.pos = startPos;
+        this.readWordText(true);
+      }
+    }
+    return this._wordParts;
+  }
+
+  /** Scan a bounded word-like span without treating shell operators or whitespace as terminators. */
+  buildEmbeddedWordParts(startPos: number, arithmetic = false): WordPart[] | null {
+    this._buildParts = true;
+    this.pos = startPos;
+    this.readInnerWordText(false, arithmetic);
+    return this._wordParts;
+  }
+
+  buildArrayElementParts(startPos: number): WordPart[] | null {
+    const close = this.findClosingBracket(startPos + 1);
+    if (close === -1) return this.buildWordParts(startPos);
+    const src = this.src;
+    this._buildParts = true;
+    const head = hasEmbeddedWordStructure(src, startPos, close + 1)
+      ? this.parseSubFieldWord(startPos, close + 1, "embedded")
+      : undefined;
+    this.pos = close + 1;
+    this.readWordText(false, LexContext.ArrayElement);
+    const end = this.pos;
+    // Only `[key]=` and `[key]+=` select an element; its key is never a pattern. Any other element
+    // is a value that undergoes pathname expansion, so one glob pass owns the whole element and a
+    // leading bracket is a pattern as in a command word.
+    const operator = skipLineContinuations(src, close + 1, end);
+    const after = src.charCodeAt(operator);
+    const keyed = after === CH_EQ || (after === CH_PLUS && src.charCodeAt(operator + 1) === CH_EQ);
+    let headParts = head?.parts;
+    let tailParts = this._wordParts;
+    if (keyed) tailParts = parseGlobParts(src, close + 1, end, tailParts) ?? tailParts;
+    if (!headParts && !tailParts) return keyed ? null : (parseGlobParts(src, startPos, end, undefined) ?? null);
+
+    const headText = src.slice(startPos, close + 1);
+    if (!headParts)
+      headParts = [{ type: "Literal", pos: startPos, end: close + 1, text: headText, value: head?.value ?? headText }];
+    if (!tailParts)
+      tailParts =
+        end > close + 1
+          ? [{ type: "Literal", pos: close + 1, end, text: src.slice(close + 1, end), value: this._wordText }]
+          : [];
+    let parts = joinWordParts(headParts, tailParts);
+    if (!keyed) parts = parseGlobParts(src, startPos, end, parts) ?? parts;
+    return parts.length > 1 || parts[0].type !== "Literal" ? parts : null;
+  }
+
+  /** Scan a heredoc body for expansions, building parts. Spaces/newlines are literal. */
+  buildHereDocParts(bodyPos: number, bodyEnd: number): WordPart[] | null {
+    this._buildParts = true;
+    const src = this.src;
+    const parts: WordPart[] = [];
+    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 /* $ */ && src.charCodeAt(i + 1) !== CH_SQUOTE && src.charCodeAt(i + 1) !== CH_DQUOTE) {
+        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: HereDoc): void {
+    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(): TokenValue {
+    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(): [string, string, string, number, number, number] {
+    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: [number, number, number] = [this.pos, 0, 0];
+    const parts: [string, string, string, number, number, number] = ["", "", "", 0, 0, 0];
+    let partIdx = 0;
+    let depth = 1;
+    let partStart = this.pos;
+    let extra = false;
+    const setPart = (end: number) => {
+      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_DOLLAR) {
+        this.readDollar();
+      } else if (c === CH_BACKTICK) {
+        this.readBacktickExpansion();
+      } else 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 {
+        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 = LexContext.Normal): TokenValue {
+    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: Uint8Array): TokenValue {
+    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 = LexContext.Normal): TokenValue {
+    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: TokenValue): void {
+    this.nextState.copyFrom(tok);
+    this.hasPeek = true;
+  }
+
+  private readNext(out: TokenValue, ctx: LexContext): void {
+    const src = this.src;
+    const len = this.srcEnd;
+
+    let pos = skipBlanks(src, this.pos, len);
+    if (ctx === LexContext.TestMode) {
+      while (pos < len && src.charCodeAt(pos) === CH_NL) pos = skipBlanks(src, pos + 1, len);
+    }
+    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);
+  }
+
+  private tryReadOperator(out: TokenValue, ch: number, ctx: LexContext, tokenStart: number): boolean {
+    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;
+    }
+  }
+
+  private readRedirection(out: TokenValue, tokenStart: number): boolean {
+    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.
+  private readRedirectTargetText(): void {
+    const savedBuildValue = this._buildValue;
+    this._buildValue = true;
+    this.readWordText();
+    this._buildValue = savedBuildValue;
+  }
+
+  private redirectToken(out: TokenValue, operator: string, tokenStart: number, targetPos: number): void {
+    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;
+  }
+
+  private readProcessSubstitution(out: TokenValue, operator: "<" | ">", tokenStart: number): void {
+    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 $ ` " \.
+  private readHereDocDelimiter(): void {
+    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;
+  }
+
+  private consumePendingHereDocs(): void {
+    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;
+  }
+
+  private hereDocClosingPos = -1;
+  private 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.
+  private matchHereDocDelimiter(delimiter: string, lineStart: number, end: number, join: boolean): number {
+    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.
+  private logicalLineEnd(from: number, end: number, join: boolean): number {
+    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;
+  }
+
+  private skipHereDocBody(delimiter: string, strip: boolean, parenEnds = false, quoted = false): number {
+    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;
+  }
+
+  private _wordText = "";
+  private _wordRaw = false;
+  private _wordQuoted = false;
+  private _wordHasExpansions = false;
+  private _wordKeywordEligible = false;
+  private _wordAssignmentState: number | undefined;
+  private _bracketWindow: { limit: number; last: number } | undefined;
+  _wordParts: WordPart[] | null = null;
+  private _resultText = "";
+  // True when the last $-construct's value is exactly its raw source span.
+  private _resultIsRaw = true;
+  private _resultHasExpansion = false;
+  private _resultPart: WordPart | undefined;
+  // Set by extractBalanced when the input ended before the closing paren, so
+  // callers can report the construct they were scanning.
+  private _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.
+  private _notArithmetic = false;
+  private _arithUnterminated = false;
+  private _dqText = "";
+  private _dqHasExpansions = false;
+  private _dqParts: DoubleQuotedChild[] | null = null;
+  // Content end (before the closing quote, or end of input when unterminated).
+  private _dqEnd = 0;
+  private _hereDelim = "";
+  private _hereQuoted = false;
+
+  private readWord(out: TokenValue, ctx: LexContext, tokenStart: number = 0): void {
+    const errorStart = this._errors === null ? 0 : this._errors.length;
+    this.readWordText(false, ctx, true);
+    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, errorStart);
+  }
+
+  private isRedirectVariable(start: number, end: number): boolean {
+    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;
+  }
+
+  private readArrayElement(out: TokenValue, tokenStart: number): boolean {
+    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;
+  }
+
+  private classifyWord(out: TokenValue, ctx: LexContext, tokenStart: number, errorStart: number): void {
+    const src = this.src;
+    const raw = this._wordRaw;
+    const hasExpansions = this._wordHasExpansions;
+    const quoted = this._wordQuoted;
+    const keywordEligible = this._wordKeywordEligible;
+    let assignmentState = this._wordAssignmentState;
+    const wordEnd = this.pos;
+    const wordLen = wordEnd - tokenStart;
+
+    if (ctx === LexContext.CasePattern) {
+      let token: Token = Token.Word;
+      if (keywordEligible) {
+        const reserved = raw
+          ? matchReservedWord(src, tokenStart, wordLen)
+          : RESERVED_WORDS.get(this.wordValueOf(tokenStart, wordEnd));
+        if (reserved === Token.Esac) token = reserved;
+      }
+      setSpanToken(out, token, tokenStart, wordEnd, raw);
+      out.keywordEligible = keywordEligible;
+      return;
+    }
+
+    // Only keyword classification needs a non-raw word's processed value.
+    let value: string | null = 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 (assignmentState === 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 || (ctx !== LexContext.Declaration && bracket)) {
+          assignmentState = scanAssignmentPrefix(src, tokenStart, wordEnd, ASSIGNMENT_NAME_START);
+        }
+      }
+      if (assignmentState !== undefined) {
+        if (ctx !== LexContext.Declaration && assignmentState >= ASSIGNMENT_INDEX_BASE) {
+          if (wordEnd < this.srcEnd) {
+            if (this._errors !== null) this._errors.length = errorStart;
+            this.pos = tokenStart;
+            this.readWordText(true, ctx, true);
+            if (this.pos > wordEnd) {
+              this.classifyWord(out, ctx, tokenStart, errorStart);
+              return;
+            }
+          }
+          if (this._errors === null || this._errors.length === errorStart) {
+            this.errors.push({ message: "unterminated array subscript", pos: src.indexOf("[", tokenStart) });
+          }
+        }
+        if (isMatchedAssignment(assignmentState)) {
+          setSpanToken(out, Token.Assignment, tokenStart, wordEnd, raw);
+          if (value !== null) out._value = value;
+          out.assignmentOperatorPos = assignmentOperatorPos(assignmentState);
+          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.
+  // `scanning` marks the first scan of a token, which decides where the word ends.
+  private readWordText(subscripts = false, ctx: LexContext = LexContext.Normal, scanning = false): void {
+    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._wordAssignmentState = undefined;
+      if (this._buildParts) {
+        this._wordParts =
+          hasGlobCharacters(this._wordText) && ctx !== LexContext.ArrayElement
+            ? (parseGlobParts(src, fastStart, pos, undefined) ?? null)
+            : 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: WordPart[] | undefined;
+    let litBuf = "";
+    let litStart = 0;
+    let hasGlobs = false;
+    if (bp) {
+      parts = [];
+      litBuf = text; // fast-path prefix is literal
+      litStart = fastStart;
+      hasGlobs = text.length > 0 && hasGlobCharacters(text);
+    }
+
+    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;
+            hasGlobs = hasGlobs || hasGlobCharacters(chunk);
+          }
+        }
+        continue;
+      }
+
+      if (charType[ch] & 1) {
+        if (subscripts && assignmentState >= ASSIGNMENT_INDEX_BASE) {
+          const close = this.findClosingBracket(pos);
+          if (close !== -1) {
+            const spanEnd = close + 1;
+            // The scanner matched the innermost open bracket past quotes, escapes and nested
+            // substitutions, so the jump closes exactly one subscript level.
+            assignmentState =
+              assignmentState === ASSIGNMENT_INDEX_BASE + 1 ? ASSIGNMENT_AFTER_INDEX : assignmentState - 1;
+            lastValueChar = src.charCodeAt(close);
+            if (bt) {
+              const chunk = src.slice(pos, spanEnd);
+              text += chunk;
+              if (bp) {
+                litBuf += chunk;
+                hasGlobs = hasGlobs || hasGlobCharacters(chunk);
+              }
+            }
+            pos = spanEnd;
+            continue;
+          }
+        }
+        if (ch === CH_LPAREN && lastValueChar < 128 && extglobPrefix[lastValueChar]) {
+          if (
+            ctx === LexContext.FunctionName ||
+            (assignmentState >= ASSIGNMENT_INDEX_BASE &&
+              (ctx === LexContext.CommandStart || ctx === LexContext.CommandPrefix))
+          )
+            break;
+          // Default Bash command syntax takes precedence over the extglob extension.
+          if (
+            ctx === LexContext.CommandStart &&
+            lastValueChar === CH_BANG &&
+            keywordEligible &&
+            src.charCodeAt(fastStart) === CH_BANG &&
+            skipLineContinuations(src, fastStart + 1, len) === pos
+          )
+            break;
+          const prefixChar = lastValueChar;
+          // Bash opens an array value only right after the operator of a word that can assign;
+          // elsewhere `(` ends the word. Rescans of a known word span keep its value.
+          if (
+            prefixChar === CH_EQ &&
+            scanning &&
+            !(
+              (ctx === LexContext.CommandStart ||
+                ctx === LexContext.CommandPrefix ||
+                ctx === LexContext.Declaration ||
+                ctx === LexContext.EvalArgument) &&
+              isMatchedAssignment(assignmentState) &&
+              skipLineContinuations(src, assignmentOperatorPos(assignmentState) + 1, len) === pos
+            )
+          )
+            break;
+          const innerStart = pos + 1;
+          const close = this.findClosingShellDelimiter(innerStart, len, CH_RPAREN, prefixChar === CH_EQ);
+          if (close === -1 && !scanning && !subscripts && assignmentState >= ASSIGNMENT_INDEX_BASE) break;
+          if (
+            ctx === LexContext.CommandStart &&
+            prefixChar !== CH_EQ &&
+            close !== -1 &&
+            skipBlanks(src, innerStart, close) === close
+          )
+            break;
+          keywordEligible = false;
+          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: this.subFieldParts(innerStart, patternEnd),
+              });
+              litStart = pos;
+            } else if (bp) {
+              litBuf += eg;
+              hasGlobs = hasGlobs || hasGlobCharacters(eg);
+            }
+          }
+          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 = this.scanBraceExpansion(pos);
+        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: this.subFieldParts(pos + 1, braceEnd - 1),
+              });
+              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._wordAssignmentState = assignmentState;
+    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;
+      if (hasGlobs && ctx !== LexContext.ArrayElement)
+        this._wordParts = parseGlobParts(src, fastStart, pos, this._wordParts) ?? null;
+    }
+  }
+
+  // Arithmetic text gets expansions and quote removal but no process substitution.
+  private readInnerWordText(insideDoubleQuotes = false, arithmetic = false, globs = false): void {
+    const src = this.src;
+    const len = this.srcEnd;
+    let pos = this.pos;
+    const start = pos;
+    let text = "";
+    const bp = this._buildParts;
+    let parts: WordPart[] | undefined;
+    let litBuf = "";
+    let litStart = 0;
+    let preserveLiteral = false;
+    let hasGlobs = false;
+    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 next = src.charCodeAt(pos);
+            if (
+              insideDoubleQuotes &&
+              next !== CH_DOLLAR &&
+              next !== CH_BACKTICK &&
+              next !== CH_DQUOTE &&
+              next !== CH_BACKSLASH &&
+              next !== CH_RBRACE
+            ) {
+              text += "\\";
+              if (bp) litBuf += "\\";
+              preserveLiteral = true;
+            }
+            const escaped = src[pos++];
+            text += escaped;
+            if (bp) litBuf += escaped;
+          }
+        }
+        continue;
+      }
+
+      if (ch === CH_SQUOTE && !insideDoubleQuotes) {
+        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(insideDoubleQuotes);
+        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(insideDoubleQuotes);
+        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(insideDoubleQuotes);
+        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 (
+        !insideDoubleQuotes &&
+        !arithmetic &&
+        (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 = "";
+          }
+          parts!.push(this.processSubstitution(psStart, raw, ch === CH_LT ? "<" : ">", inner));
+          litStart = pos;
+        }
+        continue;
+      }
+
+      text += src[pos];
+      if (bp) {
+        litBuf += src[pos];
+        if (globs && (ch === CH_STAR || ch === CH_QUESTION || ch === CH_LBRACKET)) hasGlobs = true;
+      }
+      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" || preserveLiteral)) ? parts! : null;
+      if (hasGlobs) this._wordParts = parseGlobParts(src, start, pos, this._wordParts) ?? null;
+    }
+  }
+
+  private subFieldParts(start: number, end: number): WordPart[] | undefined {
+    if (this._nestingDepth >= MAX_SYNTAX_NESTING) return undefined;
+    return hasEmbeddedWordStructure(this.src, start, end)
+      ? this.parseSubFieldWord(start, end).parts
+      : parseGlobParts(this.src, start, end, undefined);
+  }
+
+  // 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.
+  private parseSubFieldWord(start: number, end: number, context: SubFieldContext = "word", arithmetic = false): Word {
+    if (start >= end) return new WordImpl("", start, start);
+    // Past the shared budget the sub-field keeps its raw text without parts.
+    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(context === "quoted", arithmetic, context === "word");
+
+    // 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) {
+      word.parts = this._wordParts ?? undefined;
+    }
+
+    this.srcEnd = savedEnd;
+    this.pos = savedPos;
+    this._wordText = savedText;
+    this._wordParts = savedParts;
+    this._wordQuoted = savedQuoted;
+    this._wordKeywordEligible = savedKeywordEligible;
+    this._nestingDepth--;
+    return word;
+  }
+
+  private skipSQ(): void {
+    while (this.pos < this.srcEnd && this.src.charCodeAt(this.pos) !== CH_SQUOTE) this.pos++;
+    if (this.pos < this.srcEnd) this.pos++;
+  }
+
+  private skipAnsiCQuoted(): void {
+    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 });
+  }
+
+  // Plain quoted text is skipped here; the first `$(`, `${`, `$$`, backtick or the end of input
+  // hands the rest to the quote scanner, which owns substitution and nesting-limit decisions.
+  private skipDQ(): void {
+    const src = this.src;
+    const len = this.srcEnd;
+    this._unbalanced = false;
+    if (this._nestingDepth < MAX_SYNTAX_NESTING) {
+      while (this.pos < len) {
+        const ch = src.charCodeAt(this.pos);
+        if (ch === CH_DQUOTE) {
+          this.pos++;
+          return;
+        }
+        if (ch === CH_BACKSLASH) {
+          this.pos = Math.min(this.pos + 2, len);
+          continue;
+        }
+        if (ch === CH_BACKTICK) break;
+        if (ch === CH_DOLLAR) {
+          const next = src.charCodeAt(this.pos + 1);
+          if (next === CH_LPAREN || next === CH_LBRACE || next === CH_DOLLAR) break;
+        }
+        this.pos++;
+      }
+    }
+    this.extractBalanced(true, true);
+  }
+
+  private skipSpacesAndTabs(): void {
+    this.pos = skipBlanks(this.src, this.pos, this.srcEnd);
+  }
+
+  private readDoubleQuoted(unescapeAll = false): void {
+    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: DoubleQuotedChild[] | null = 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 (
+              unescapeAll ||
+              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(true);
+        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;
+  }
+
+  private readDollar(insideDoubleQuotes = false): void {
+    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(insideDoubleQuotes);
+      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(insideDoubleQuotes);
+      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 errorCount = this._errors === null ? 0 : this._errors.length;
+      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
+          ? this.arithmeticExpansion(bodyStart - 2, text, body, bodyStart)
+          : undefined;
+        return;
+      }
+      // A failed lookahead leaves `$` literal and the token path re-reads the scanned text.
+      if (this._errors !== null) this._errors.length = errorCount;
+    }
+
+    this._resultText = "$";
+    this._resultIsRaw = true;
+    this._resultHasExpansion = false;
+    this._resultPart = undefined;
+  }
+
+  private scanArithmeticBody(): string {
+    this._notArithmetic = false;
+    this._arithUnterminated = false;
+    this.pos += 2;
+    let depth = 1;
+    let parenDepth = 0;
+    let parentParenDepth = 0;
+    let parenDepths: number[] | undefined;
+    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;
+          if (depth + this._nestingDepth > MAX_SYNTAX_NESTING && !reported) {
+            this.errors.push({ message: "maximum arithmetic expansion nesting depth exceeded", pos: this.pos - 1 });
+            reported = true;
+          }
+          this.pos += 2;
+        } else {
+          // The expression parser stops building structure at this depth; report it here, while
+          // scanning, since the expression itself resolves lazily. Each enclosing `$((` of this
+          // scan parses one level deeper, so its parentheses count from there.
+          if (++parenDepth + depth - 1 + this._nestingDepth > MAX_SYNTAX_NESTING && !reported) {
+            this.errors.push({ message: "maximum arithmetic expression nesting depth exceeded", pos: this.pos });
+            reported = true;
+          }
+          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) : "";
+  }
+
+  private readArithmeticExpansion(dollarPos: number): void {
+    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 ? this.arithmeticExpansion(dollarPos, text, body, bodyStart) : undefined;
+  }
+
+  private arithmeticExpansion(
+    pos: number,
+    text: string,
+    body: string,
+    bodyStart: number,
+  ): import("./internal-types.ts").ArithmeticExpansionPart {
+    return new ArithmeticExpansionImpl(pos, this.pos, text, {
+      source: this.src,
+      body,
+      offset: bodyStart,
+      depth: this._nestingDepth,
+      context: this.substitutionContext,
+    });
+  }
+
+  private readArithmeticCommand(out: TokenValue, tokenStart: number): void {
+    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);
+  }
+
+  private readCommandSubstitution(dollarPos: number): void {
+    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 = this.commandExpansion(dollarPos, rawText, openPos + 1, inner, !this._unbalanced);
+    } else {
+      this._resultPart = undefined;
+    }
+  }
+
+  private readBraceCommandSubstitution(): void {
+    this.readBraceSubstitution(1);
+  }
+
+  private readValueSubstitution(): void {
+    this.readBraceSubstitution(2);
+  }
+
+  private readBraceSubstitution(skip: number): void {
+    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 = this.commandExpansion(dollarPos, text, innerStart, inner);
+      } else {
+        this._resultPart = undefined;
+      }
+    } else {
+      this._resultText = "";
+      this._resultPart = undefined;
+    }
+  }
+
+  private readBacktickExpansion(insideDoubleQuotes = false): void {
+    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) {
+      this._resultPart = hasEscapes
+        ? this.decodedCommandExpansion(start - 1, text, inner)
+        : this.commandExpansion(start - 1, text, start, inner);
+    } else {
+      this._resultPart = undefined;
+    }
+  }
+
+  private readParameterExpansion(insideDoubleQuotes: boolean): void {
+    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, insideDoubleQuotes);
+    } 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.
+  private parseParamInner(
+    text: string,
+    inner: string,
+    innerStart: number,
+    insideDoubleQuotes: boolean,
+  ): ParameterExpansionPart {
+    const result: ParameterExpansionPart = {
+      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: number, b: number, context: SubFieldContext = "word"): Word =>
+      this.parseSubFieldWord(innerStart + a, innerStart + b, context);
+    const closeBracket = (start: number): number => {
+      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, "embedded");
+        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, "embedded");
+        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, insideDoubleQuotes ? "quoted" : "word"),
+      };
+      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, "embedded"),
+        length: colonIdx === -1 ? undefined : sub(i + colonIdx + 1, ilen, "embedded"),
+      };
+      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: import("./internal-types.ts").ParameterReplaceOperation["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;
+  }
+
+  private findNestedShellEnd(start: number, end: number, quoted: boolean): number {
+    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: number;
+    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;
+  }
+
+  private scanParamName(s: string, start: number): number {
+    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;
+  }
+
+  private readAnsiCQuoted(): string {
+    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;
+  }
+
+  // Quotes resume when a nested substitution returns to their parenthesis depth.
+  private extractBalanced(useGrammar = true, quoteOnly = false): string {
+    const src = this.src;
+    const len = this.srcEnd;
+    const bt = this._buildParts || this._buildValue;
+    let depth = quoteOnly ? 0 : 1;
+    const start = this.pos;
+    this._unbalanced = false;
+    const knownEnd = useGrammar && !quoteOnly ? this.substitutionContext.boundaries?.get(start) : undefined;
+    if (knownEnd !== undefined && knownEnd <= len && this._nestingDepth < MAX_SYNTAX_NESTING) {
+      this.pos = knownEnd;
+      return bt ? src.slice(start, knownEnd - 1) : "";
+    }
+    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 (!quoteOnly && 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 ||
+        (c === CH_DOLLAR && (src.charCodeAt(this.pos + 1) === CH_SQUOTE || src.charCodeAt(this.pos + 1) === CH_DOLLAR))
+      ) {
+        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: boolean[] = [];
+    type Delimiter = { delimiter: string; strip: boolean; quoted: boolean };
+    type ScriptScope = {
+      start: number;
+      dollar: number;
+      depth: number;
+      parens: number;
+      caseDepth: number;
+      caseParens: number;
+      arithBase: number;
+      arithExtent: boolean;
+      substitutions: number;
+      checkedGrammar: boolean;
+      pendingDelims: Delimiter[] | null;
+    };
+    let pendingDelims: Delimiter[] | null = null;
+    let scripts: ScriptScope[] | undefined;
+    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.
+    let 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;
+    type QuoteScope = { close: number; depth: number };
+    const quotes: QuoteScope[] = quoteOnly ? [{ close: CH_DQUOTE, depth: 0 }] : [];
+    let quotedDepth = quoteOnly ? 1 : 0;
+    let parameterDepth = 0;
+    let arithmeticOpens: number[] | undefined;
+    let continuedDollarPos = -1;
+    let continuedParenPos = -1;
+    let escapedEnd = -1;
+    let lastParenEnd = -1;
+    let checkedGrammar = false;
+
+    while (this.pos < len && (depth > 0 || quotes.length > 0)) {
+      let ch = src.charCodeAt(this.pos);
+      // A negative index would leave V8's fast array path, so guard the empty stack.
+      const quote = quotes.length === 0 ? undefined : quotes[quotes.length - 1];
+      if (quote !== undefined && quote.depth === depth) {
+        let commandOpen = false;
+        if (ch === CH_BACKSLASH) {
+          this.pos = Math.min(this.pos + 2, len);
+          continue;
+        }
+        if (ch === quote.close) {
+          quotes.pop();
+          if (ch === CH_DQUOTE) quotedDepth--;
+          else parameterDepth--;
+          this.pos++;
+          if (quoteOnly && depth === 0 && quotes.length === 0) return "";
+          continue;
+        }
+        if (ch === CH_DQUOTE) {
+          quotes.push({ close: CH_DQUOTE, depth });
+          quotedDepth++;
+        } else if (ch === CH_SQUOTE && quote.close === CH_RBRACE) {
+          this.pos++;
+          this.skipSQ();
+          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++;
+            if (this.pos < len) this.pos++;
+          }
+          if (this.pos < len) this.pos++;
+          continue;
+        } else if (ch === CH_DOLLAR) {
+          const next = src.charCodeAt(this.pos + 1);
+          if (next === CH_LBRACE) {
+            quotes.push({ close: CH_RBRACE, depth });
+            parameterDepth++;
+            this.pos++;
+          } else if (next === CH_LPAREN) {
+            this.pos++;
+            ch = CH_LPAREN;
+            commandOpen = true;
+          } else if (next === CH_DOLLAR) {
+            // `$$` is one parameter unless `(` follows: Bash's quote scanner then reads `$` + `$(`.
+            this.pos += src.charCodeAt(this.pos + 2) === CH_LPAREN ? 1 : 2;
+            continue;
+          }
+        }
+        if (!reported && this._nestingDepth + Math.max(quotedDepth, parameterDepth) > MAX_SYNTAX_NESTING) {
+          this.errors.push({ message: "maximum word nesting depth exceeded", pos: this.pos });
+          reported = true;
+        }
+        if (!commandOpen) {
+          // Plain text changes no depth, so the rest of the run needs no further checks.
+          this.pos++;
+          while (this.pos < len) {
+            const c = src.charCodeAt(this.pos);
+            if (
+              c === CH_BACKSLASH ||
+              c === CH_DQUOTE ||
+              c === CH_DOLLAR ||
+              c === CH_BACKTICK ||
+              c === CH_RBRACE ||
+              c === CH_SQUOTE
+            )
+              break;
+            this.pos++;
+          }
+          continue;
+        }
+      }
+      // The grammar resolves whether '#' after ')' is a comment, including inside array subscripts.
+      if (
+        ch === CH_HASH &&
+        lastParenEnd !== -1 &&
+        !arithExtent &&
+        arithBase < 0 &&
+        useGrammar &&
+        !checkedGrammar &&
+        this._nestingDepth + (scripts?.length ?? 0) < MAX_SYNTAX_NESTING &&
+        skipBlanks(src, lastParenEnd, len) === this.pos
+      ) {
+        checkedGrammar = true;
+        const scope = scripts?.[scripts.length - 1];
+        const end = this.findSubstitutionEnd(
+          scope?.start ?? start,
+          len,
+          this._nestingDepth + (scripts?.length ?? 0) + 1,
+        );
+        if (end !== -1) {
+          if (scope === undefined) {
+            this.pos = end;
+            return bt ? src.slice(start, end - 1) : "";
+          }
+          // Rejoin the closing-parenthesis path so the proven script end restores its enclosing scope.
+          this.pos = end - 1;
+          depth = scope.depth + 1;
+          caseDepth = 0;
+          caseParens = 0;
+          wordStartAfterParen.length = scope.parens + 1;
+          ch = CH_RPAREN;
+        }
+      }
+      if (ch === CH_LPAREN) {
+        // An escaped character (`\$(`) is text, not a substitution or extglob prefix.
+        const prev = this.pos > start && this.pos !== escapedEnd ? 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);
+        const script =
+          (commandDollarPos !== -1 && src.charCodeAt(this.pos + 1) !== CH_LPAREN) ||
+          ((prev === CH_LT || prev === CH_GT) && arithBase < 0 && !arithExtent);
+        if (script) {
+          (scripts ?? (scripts = [])).push({
+            start: this.pos + 1,
+            dollar: commandDollarPos,
+            depth,
+            parens: wordStartAfterParen.length,
+            caseDepth,
+            caseParens,
+            arithBase,
+            arithExtent,
+            substitutions,
+            checkedGrammar,
+            pendingDelims,
+          });
+          caseDepth = 0;
+          caseParens = 0;
+          arithBase = -1;
+          arithExtent = false;
+          checkedGrammar = false;
+          pendingDelims = null;
+        }
+        wordStartAfterParen.push(!wordParen);
+        wordStart = true;
+        // (( opens arithmetic — suppress heredoc detection until the parens
+        // rebalance so shift operators inside aren't mistaken for heredocs
+        if (!script && arithBase < 0 && this.pos + 1 < len && src.charCodeAt(this.pos + 1) === CH_LPAREN) {
+          arithBase = depth;
+        }
+        if (commandDollarPos !== -1) {
+          if (script) substitutions++;
+          else (arithmeticOpens ?? (arithmeticOpens = [])).push(depth);
+          if (
+            substitutions + (arithmeticOpens?.length ?? 0) + this._nestingDepth + (quoteOnly ? 0 : 1) >
+              MAX_SYNTAX_NESTING &&
+            !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 && !quoteOnly) {
+            const result = bt ? src.slice(start, this.pos) : "";
+            this.pos++;
+            return result;
+          }
+          if (depth <= arithBase) arithBase = -1;
+          if (arithmeticOpens !== undefined) {
+            while (arithmeticOpens.length > 0 && arithmeticOpens[arithmeticOpens.length - 1] >= depth)
+              arithmeticOpens.pop();
+          }
+          wordStart = wordStartAfterParen.pop() ?? true;
+          this.pos++;
+          const scope = scripts?.[scripts.length - 1];
+          if (scope !== undefined && scope.depth === depth) {
+            scripts!.pop();
+            caseDepth = scope.caseDepth;
+            caseParens = scope.caseParens;
+            arithBase = scope.arithBase;
+            arithExtent = scope.arithExtent;
+            substitutions = scope.substitutions;
+            checkedGrammar = scope.checkedGrammar;
+            pendingDelims = scope.pendingDelims;
+          }
+        }
+        lastParenEnd = 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++;
+        }
+        escapedEnd = this.pos;
+      } else if (ch === CH_DOLLAR) {
+        const next = src.charCodeAt(++this.pos);
+        if (next === CH_SQUOTE) {
+          this.pos++;
+          this.skipAnsiCQuoted();
+        } else if (next === CH_DOLLAR) {
+          this.pos++;
+        }
+        wordStart = false;
+      } else if (ch === CH_SQUOTE) {
+        this.pos++;
+        this.skipSQ();
+        wordStart = false;
+      } else if (ch === CH_DQUOTE) {
+        quotes.push({ close: CH_DQUOTE, depth });
+        quotedDepth++;
+        this.pos++;
+        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 && arithBase < 0 && !arithExtent) {
+            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. A quoted scan owns the `$(` it opened: the
+    // outermost one left open is reported here, since no token read revisits this text.
+    this._unbalanced = true;
+    if (quoteOnly && scripts !== undefined && scripts.length > 0) {
+      this.errors.push({ message: "unterminated command substitution", pos: scripts[0].dollar });
+    }
+    return bt ? src.slice(start, this.pos) : "";
+  }
+}