@opencode/core 0.0.0-dev-20573 → 0.0.0-dev-20577

package/dist/shell/scan.js

@@ -1,6 +1,6 @@
 import {
   __export
-} from "../chunks/managed-policy-9rqn6x4v.js";
+} from "../chunks/command-9rqn6x4v.js";
 
 // src/shell/scan.ts
 var exports_scan = {};
@@ -10,716 +10,1271 @@ __export(exports_scan, {
   scanPowerShell: () => scanPowerShell
 });
 var BASH_REDIRECTS = ["&>>", "&>", "<<<", "<<-", "<<", "<>", "<&", ">&", ">|", ">>", ">", "<"];
-var BASH_DECLARATIONS = new Set(["declare", "typeset", "export", "readonly", "local", "unset", "unsetenv"]);
+var BASH_LIST_OPERATORS = ["&&", "||", "|&"];
+var BASH_CASE_OPERATORS = [";;&", ";;", ";&", ";|", ...BASH_LIST_OPERATORS];
+var BASH_BINDING_BUILTINS = new Set([
+  "declare",
+  "typeset",
+  "local",
+  "export",
+  "readonly",
+  "private",
+  "unset",
+  "read",
+  "getln",
+  "vared",
+  "getopts",
+  "mapfile",
+  "readarray",
+  "compgen",
+  "zparseopts",
+  "zregexparse",
+  "zformat",
+  "zstyle",
+  "zstat",
+  "stat"
+]);
+var BASH_ARITHMETIC_COMPARISONS = new Set(["-eq", "-ne", "-lt", "-le", "-gt", "-ge"]);
+var BASH_EXPANSION_RE = /\$(?:\\.|\\\n)*[({]|`/;
+var BASH_ESCAPE_RE = /\\(?:x[\da-fA-F]{1,2}|[0-7]{1,3}|u[\da-fA-F]{1,4}|U[\da-fA-F]{1,8})/;
+var BASH_ASSIGNMENT_DECLARATIONS = new Set(["declare", "typeset", "export", "readonly", "local"]);
+var BASH_DECLARATIONS = new Set([...BASH_ASSIGNMENT_DECLARATIONS, "unset", "unsetenv"]);
+var BASH_PRECOMMANDS = new Set(["builtin", "command", "time", "coproc", "!"]);
+var ZSH_PRECOMMANDS = new Set(["noglob", "nocorrect", "exec", "-"]);
+var ZSH_ARITHMETIC_BUILTINS = new Set([
+  "integer",
+  "float",
+  "exit",
+  "return",
+  "shift",
+  "break",
+  "continue",
+  "bye",
+  "logout"
+]);
+var BASH_NON_FUNCTION_KEYWORDS = new Set([
+  "if",
+  "for",
+  "select",
+  "case",
+  "then",
+  "elif",
+  "else",
+  "fi",
+  "do",
+  "done",
+  "in",
+  "esac"
+]);
+var BASH_UNIT_STARTS = "\\$'\"`<>";
 var MAX_INPUT_LENGTH = 64 * 1024;
 var MAX_SUBSTITUTION_DEPTH = 32;
-function scan(input) {
-  return scanBash(input, 0, { remaining: MAX_INPUT_LENGTH * MAX_SUBSTITUTION_DEPTH });
+var TOKEN_RE = /[A-Za-z_][A-Za-z0-9_]*(?=(?:\\\n)*(?:[ \t\n;|&()<>]|$))/y;
+var BRACE_CLOSE_AHEAD_RE = /(?:\\\n)*(?:[ \t\n;&|()<>]|$)/y;
+var SPACE_CONTINUATION_AHEAD_RE = /(?:\\\n)*[ \t\n]/y;
+var NEGATION_AHEAD_RE = /(?:\\\n)*[ \t\n(]/y;
+var COPROC_AHEAD_RE = /coproc(?:[ \t]|\\\n)+(?:--(?:[ \t]|\\\n)+)?(?:[A-Za-z_][A-Za-z0-9_]*(?:[ \t]|\\\n)+)?(?=(?:!(?:[ \t]|\\\n)*)*(?:[{(]|\[\[(?:\\\n)*[ \t\n]|(?:if|while|until|for|select|case|repeat)\b))/y;
+var TIME_AHEAD_RE = /time(?:[ \t]|\\\n)+(?:-p(?:[ \t]|\\\n)+)?(?:--(?:[ \t]|\\\n)+)?(?=(?:!(?:[ \t]|\\\n)*)*(?:[{(]|\[\[(?:\\\n)*[ \t\n]|(?:if|while|until|for|select|case|repeat)\b))/y;
+var FUNCTION_HEAD_RE = /(function[ \t](?:[ \t]|\\\n)*)?([A-Za-z_][\w.:+@%-]*)?(?:[ \t]|\\\n)*(\([ \t]*\))?((?:[ \t\n]|\\\n|#[^\n]*\n)*)/y;
+var FUNCTION_BODY_RE = /[{(]|\[\[(?=(?:\\\n)*[ \t\n])|(?:if|while|until|for|select|case|repeat)(?=(?:\\\n)*(?:[ \t\n(]|$))/y;
+var DO_AHEAD_RE = /(?:[ \t\n;]|\\\n|#[^\n]*(?:\n|$))*(?:do(?=(?:\\\n)*(?:[ \t\n;{(]|$))|\{(?=(?:\\\n)*[ \t\n]))/y;
+var NOFORK_OPEN_RE = /\$\{(?:\\\n)*(?:[ \t\n]|\|)/y;
+var ZSH_SAFE_FLAGS_RE = /\$\{\((?:[@AaBbCcDEfFikLMmNnOopqStUuVvWwXZz0-]|q[-+]?|[js]([^({[<\\])(?:(?!\1)[^)])*\1)*\)/y;
+var ZSH_GLOB_MODIFIER_RE = /(?:[\^=~#+]|\\\n)*~/y;
+var ZSH_SUBSCRIPT_RE = /\$(?:[\^=+~#]|\\\n)*(?:[A-Za-z_](?:[A-Za-z0-9_]|\\\n)*|[@*#?$!0-9-])(?:\\\n)*\[/y;
+var LINE_CONTINUATION_RE = /(?:\\\n)*/y;
+var PARAMETER_PREFIX_RE = /(?:\\\n)*(?:\([^)]*\))?(?:[!#^=+~]|\\\n)*/y;
+var PARAMETER_NAME_RE = /(?:[A-Za-z_](?:[A-Za-z0-9_]|\\\n)*|\d(?:\d|\\\n)*|[@*#?$!-])(?:\\\n)*/y;
+var PARAMETER_PROMPT_RE = /@(?:\\\n)*[EP](?:\\\n)*\}/y;
+var BASH_ANSI_ESCAPES = {
+  a: "\x07",
+  b: "\b",
+  e: "\x1B",
+  E: "\x1B",
+  f: "\f",
+  n: `
+`,
+  r: "\r",
+  t: "\t",
+  v: "\v",
+  "\\": "\\",
+  "'": "'",
+  '"': '"',
+  "?": "?"
+};
+function scan(input, dialect = "posix") {
+  if (input.length > MAX_INPUT_LENGTH)
+    return { kind: "opaque", reason: "invalid-structure" };
+  const context = { remaining: MAX_INPUT_LENGTH * MAX_SUBSTITUTION_DEPTH, dialect };
+  const result = scanBash(input, 0, 0, context);
+  if (result.kind === "opaque")
+    return result;
+  if (context.boundDollar && context.boundOpen && context.variableSink)
+    return { kind: "opaque", reason: "dynamic-execution" };
+  return { kind: "scanned", commands: result.commands };
 }
-function scanBash(input, depth, budget) {
-  budget.remaining -= input.length;
-  if (input.length > MAX_INPUT_LENGTH || budget.remaining < 0 || depth > MAX_SUBSTITUTION_DEPTH)
+function bashStatement(state) {
+  const structure = state.structures.at(-1);
+  if (structure)
+    structure.count++;
+}
+function bashInHeader(state) {
+  const phase = state.structures.at(-1)?.phase;
+  return phase === "header" || phase === "pattern" || phase === "do";
+}
+function atCommandStart(state) {
+  return !state.words.length && !state.hasRedirect && !state.compoundEnd && !bashInHeader(state);
+}
+function pending(state) {
+  return state.wordStarted || state.words.length > 0 || state.hasRedirect || state.compoundEnd;
+}
+function endBashList(state) {
+  if (pending(state))
+    finishBashCommand(state);
+  return !state.dangling;
+}
+function closeBashList(state, end) {
+  if (!endBashList(state))
     return { kind: "opaque", reason: "invalid-structure" };
-  const commands = [];
-  const nestedCommands = [];
-  const words = [];
-  const rawWords = [];
-  const assignmentWords = [];
-  let word = "";
-  let wordStarted = false;
-  let wordStart = 0;
-  let wordEnd = 0;
-  let commandEnd = 0;
-  let resourceEnd;
-  let redirectWordCount;
-  let assignmentWord = false;
-  let assignmentHeadUnsafe = false;
-  let segment = 0;
-  let quote;
-  let invalidRedirect = false;
-  let invalidStructure = false;
-  let separated = false;
-  let redirectTarget = false;
-  let hasRedirect = false;
-  let dangling = false;
-  let inList = false;
-  let compoundEnd = false;
-  const heredocs = [];
-  const structures = [];
-  const addSubstitutions = (substitution) => {
-    for (const source of substitution.substitutions ?? [substitution.source]) {
-      const result = scanBash(source, depth + 1, budget);
-      if (result.kind === "opaque")
-        return result;
-      nestedCommands.push(...result.commands);
-    }
-  };
-  const statement = () => {
-    const structure = structures.at(-1);
-    if (structure)
-      structure.count++;
-  };
-  const header = () => ["header", "pattern", "do"].includes(structures.at(-1)?.phase ?? "");
-  const finishWord = () => {
-    if (!wordStarted)
-      return;
-    if (!redirectTarget) {
-      words.push(word);
-      rawWords.push(input.slice(wordStart, wordEnd));
-      assignmentWords.push(assignmentWord);
-      commandEnd = wordEnd;
+  if (state.invalid)
+    return { kind: "opaque", reason: state.invalid };
+  if (state.structures.length)
+    return { kind: "opaque", reason: "compound-command" };
+  return { kind: "scanned", commands: state.commands, end };
+}
+function finishBashWord(state) {
+  if (!state.wordStarted)
+    return;
+  if (/PS4/.test(state.word))
+    state.context.variableSink = true;
+  const evaluation = bashWordEvaluation(state);
+  if (state.context.dialect !== "bash" && (/(?:READ)?NULLCMD/.test(state.word) || (state.assignmentWord || evaluation === "binding") && /^(?:-[A-Za-z]*v)?(?:(?:dis_)?(?:functions|[gs]?aliases)|options|commands)(?:\+?=|\[|$)/.test(state.word)))
+    state.invalid ??= "dynamic-execution";
+  if (evaluation && bashEvaluatesExpansion(state, evaluation, state.context))
+    state.invalid ??= "dynamic-execution";
+  if (state.outer)
+    state.outer.output += ` ${state.literal} ${state.output}`;
+  const structure = state.structures.at(-1);
+  const repeatHeader = structure?.kind === "repeat" && structure.phase === "header";
+  if (!state.redirectTarget && repeatHeader)
+    structure.phase = "do";
+  if (!state.redirectTarget && !repeatHeader) {
+    if (!state.assignmentWord && state.commandWordIndex < 0)
+      state.commandWordIndex = state.words.length;
+    state.commandStart ??= state.wordStart;
+    state.words.push(state.word);
+    state.rawWords.push(state.input.slice(state.wordStart, state.wordEnd));
+    state.commandEnd = state.wordEnd;
+  }
+  state.redirectTarget = false;
+  state.hereString = false;
+  state.word = "";
+  state.literal = "";
+  state.output = "";
+  state.wordStarted = false;
+  state.assignmentWord = false;
+  state.assignmentHeadUnsafe = false;
+}
+function bashWordEvaluation(state) {
+  if (state.redirectTarget)
+    return state.hereString ? "deferred" : undefined;
+  const structure = state.structures.at(-1);
+  if (structure?.kind === "repeat" && structure.phase === "header")
+    return "arithmetic";
+  if (structure?.kind === "for" && structure.phase === "header" && structure.sawIn)
+    return "deferred";
+  if (state.commandWordIndex < 0)
+    return state.assignmentWord ? "deferred" : undefined;
+  const name = bashBuiltinIndex(state);
+  const command = state.words[name];
+  if (command === undefined)
+    return;
+  if (command === "let" || state.context.dialect !== "bash" && ZSH_ARITHMETIC_BUILTINS.has(command))
+    return "arithmetic";
+  if (command === "set")
+    return state.words.slice(name + 1).some((word) => /^[-+][A-Za-z0-9]*A/.test(word)) ? "binding" : "deferred";
+  if (BASH_BINDING_BUILTINS.has(command)) {
+    const options = state.words.slice(name + 1);
+    if (options.some((word) => word.startsWith("-") && /[EFin]/.test(word)))
+      return "arithmetic";
+    if (state.assignmentWord && BASH_ASSIGNMENT_DECLARATIONS.has(command) && options.every((word) => !word.startsWith("-")) && (command === "export" || command === "readonly" || state.context.dialect === "zsh" || !/\+?=(?:\(|[$`])/.test(state.word)))
+      return "deferred";
+    return "binding";
+  }
+  if (command === "printf" || command === "print") {
+    const options = [...state.words.slice(name + 1), state.word];
+    const flag = command === "print" ? /^-[A-Za-z]*v/ : /^-v/;
+    return options.some((word) => flag.test(word)) ? "binding" : undefined;
+  }
+  if (command === "wait")
+    return /^-[nf]*p/.test(state.word) || /^-[nf]*p$/.test(state.words.at(-1) ?? "") ? "binding" : undefined;
+  if (command === "test" || command === "[") {
+    if (state.words.at(-1) === "-v")
+      return "binding";
+    if (state.context.dialect !== "bash" && state.words.at(-1) === "-t")
+      return "arithmetic";
+  }
+  return;
+}
+function bashBuiltinIndex(state) {
+  let name = state.commandWordIndex;
+  while (BASH_PRECOMMANDS.has(state.words[name] ?? "") || state.context.dialect !== "bash" && ZSH_PRECOMMANDS.has(state.words[name] ?? "")) {
+    const precommand = state.words[name++];
+    while (precommand !== "-" && state.words[name]?.startsWith("-")) {
+      if (precommand === "exec" && /^-[cl]*a$/.test(state.words[name]))
+        name++;
+      name++;
     }
-    redirectTarget = false;
-    word = "";
-    wordStarted = false;
-    assignmentWord = false;
-    assignmentHeadUnsafe = false;
-  };
-  const finishCommand = (boundary = false) => {
-    finishWord();
-    if (redirectTarget)
-      invalidRedirect = true;
-    redirectTarget = false;
-    if (compoundEnd && words.length > 0)
-      invalidStructure = true;
-    const resource = input.slice(segment, resourceEnd ?? wordEnd).replace(/^[ \t\n]+|[ \t\n]+$/g, "");
-    const name = assignmentWords.findIndex((assignment) => !assignment);
-    if (name >= 0 && !words[name])
-      invalidStructure = true;
-    if (rawWords[name] === "}")
-      invalidStructure = true;
-    if (resource && name >= 0 && !header()) {
-      const command = {
-        resource,
-        words: words.slice(name),
-        rawWords: rawWords.slice(name),
-        ...name === 0 && BASH_DECLARATIONS.has(rawWords[0]) && resource.startsWith(rawWords[0]) ? { declaration: true } : {},
-        ...redirectWordCount !== undefined && redirectWordCount < words.length ? { redirectWordCount: redirectWordCount - name } : {}
-      };
-      commands.push(command);
-      if (resourceEnd === undefined) {
-        for (const heredoc of heredocs) {
-          if (heredoc.command)
-            continue;
-          heredoc.command = command;
-          heredoc.start = segment;
-        }
+  }
+  return name;
+}
+function finishBashCommand(state, boundary = false) {
+  finishBashWord(state);
+  if (state.redirectTarget)
+    state.invalid ??= "invalid-redirect";
+  state.redirectTarget = false;
+  if (state.compoundEnd && state.words.length > 0)
+    state.invalid ??= "invalid-structure";
+  const name = state.commandWordIndex;
+  const inHeader = bashInHeader(state);
+  if (name >= 0 && !state.words[name])
+    state.invalid ??= "invalid-structure";
+  if (name >= 0 && !inHeader) {
+    const resource = state.input.slice(state.commandStart, state.resourceEnd ?? state.wordEnd).replace(/^[ \t\n]+|[ \t\n]+$/g, "");
+    const command = {
+      resource,
+      words: state.words.slice(name),
+      rawWords: state.rawWords.slice(name),
+      ...name === 0 && BASH_DECLARATIONS.has(state.rawWords[0]) && resource.startsWith(state.rawWords[0]) ? { declaration: true } : {},
+      ...state.redirectWordCount !== undefined && state.redirectWordCount < state.words.length ? { redirectWordCount: state.redirectWordCount - name } : {}
+    };
+    state.commands.push(command);
+    const builtin = bashBuiltinIndex(state);
+    const builtinName = state.words[builtin];
+    const builtinArgs = state.words.slice(builtin + 1);
+    if (builtinName === "eval")
+      state.context.variableSink = true;
+    if (builtinName === "set" && builtinArgs.some((word) => /^-[A-Za-z0-9]*k/.test(word) || word === "keyword"))
+      state.invalid ??= "dynamic-execution";
+    if (builtinName === "alias" && builtinArgs.some((word) => word.includes("=")))
+      state.invalid ??= "dynamic-execution";
+    if (state.context.dialect !== "bash" && (builtinName === "emulate" || (builtinName === "setopt" || builtinName === "unsetopt" || builtinName === "set" && builtinArgs.some((word) => /^[-+][A-Za-z0-9]*o/.test(word))) && builtinArgs.some((word) => /^-[A-Za-z0-9]*m/.test(word) || /^(?:no)?(?:globsubst|kshglob|promptsubst|promptvars|aliases)$/.test(word.replace(/^[-+][A-Za-z0-9]*?o/i, "").toLowerCase().replace(/[_-]/g, "")))))
+      state.invalid ??= "dynamic-execution";
+    if (state.context.dialect !== "zsh" && builtinName === "compgen" && builtinArgs.some((word) => word.startsWith("-") && /[CF]/.test(word)))
+      state.invalid ??= "dynamic-execution";
+    if (BASH_BINDING_BUILTINS.has(builtinName ?? "")) {
+      for (const heredoc of state.heredocs)
+        heredoc.binding ??= true;
+    }
+    if (state.resourceEnd === undefined) {
+      for (const heredoc of state.heredocs) {
+        if (heredoc.command)
+          continue;
+        heredoc.command = command;
+        heredoc.start = state.commandStart;
       }
-    } else if (!header() && !compoundEnd && (hasRedirect || boundary || separated)) {
-      const assignmentOnly = assignmentWords.length > 0 && assignmentWords.every(Boolean);
-      if (!assignmentOnly && !hasRedirect)
-        invalidStructure = true;
     }
-    commands.push(...nestedCommands.splice(0));
-    if (!header() && (words.length > 0 || hasRedirect))
-      statement();
-    words.length = 0;
-    rawWords.length = 0;
-    assignmentWords.length = 0;
-    separated = true;
-    hasRedirect = false;
-    resourceEnd = undefined;
-    redirectWordCount = undefined;
-    compoundEnd = false;
+  }
+  if (boundary && !state.words.length && !state.hasRedirect && !state.compoundEnd && !inHeader)
+    state.invalid ??= "invalid-structure";
+  if (state.words.length > (state.ampersandRedirectWords ?? Infinity))
+    state.invalid ??= "invalid-redirect";
+  state.commands.push(...state.nestedCommands.splice(0));
+  if (!inHeader && (state.words.length > 0 || state.hasRedirect))
+    bashStatement(state);
+  state.words.length = 0;
+  state.rawWords.length = 0;
+  state.commandWordIndex = -1;
+  state.commandStart = undefined;
+  state.hasRedirect = false;
+  state.resourceEnd = undefined;
+  state.redirectWordCount = undefined;
+  state.ampersandRedirectWords = undefined;
+  state.compoundEnd = false;
+  state.dangling = false;
+}
+function scanBash(input, start, depth, context, close, heredocs, outer) {
+  if (depth > MAX_SUBSTITUTION_DEPTH || context.remaining < 0)
+    return { kind: "opaque", reason: "invalid-structure" };
+  const state = {
+    input,
+    context,
+    commands: [],
+    nestedCommands: [],
+    words: [],
+    rawWords: [],
+    heredocs: heredocs ?? [],
+    structures: [],
+    word: "",
+    literal: "",
+    output: "",
+    wordStarted: false,
+    wordStart: start,
+    wordEnd: start,
+    commandStart: undefined,
+    commandEnd: start,
+    resourceEnd: undefined,
+    redirectWordCount: undefined,
+    ampersandRedirectWords: undefined,
+    commandWordIndex: -1,
+    assignmentWord: false,
+    assignmentHeadUnsafe: false,
+    invalid: undefined,
+    redirectTarget: false,
+    hereString: false,
+    hasRedirect: false,
+    compoundEnd: false,
+    dangling: false,
+    outer
   };
-  for (let index = 0;index < input.length; index++) {
+  for (let index = start;index < input.length; index++) {
+    if (--context.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
     const char = input[index];
-    if (!wordStarted)
-      wordStart = index;
-    if (!quote && !wordStarted) {
+    if (char === "\\" && input[index + 1] === `
+`) {
+      index++;
+      continue;
+    }
+    if (!state.wordStarted) {
+      state.wordStart = index;
       if (char === " " || char === "\t")
         continue;
-      const structure = structures.at(-1);
-      const token = /^[A-Za-z_][A-Za-z0-9_]*(?=[ \t\n;()<>]|$)/.exec(input.slice(index))?.[0];
-      if (structure?.kind === "case" && structure.phase === "header" && token === "in") {
-        finishCommand();
-        structure.phase = "pattern";
-        index += token.length - 1;
-        segment = index + 1;
-        continue;
-      }
-      if (structure?.phase === "pattern" && (char === "(" || char === "|"))
-        continue;
-      if (structure?.phase === "pattern" && char === ")") {
-        finishCommand();
-        structure.phase = "body";
-        structure.count = 0;
-        segment = index + 1;
-        continue;
-      }
-      if (structure?.kind === "for" && structure.phase === "header" && char === "(" && input[index + 1] !== "(") {
-        const values = bashExpansion(input, index, depth, "array");
-        if (!values)
-          return { kind: "opaque", reason: "compound-command" };
-        finishCommand();
-        const failure = addSubstitutions(values);
-        if (failure)
-          return failure;
-        commands.push(...nestedCommands.splice(0));
-        structure.phase = "do";
-        if (!/^(?:[ \t\n;]|\\\n|#[^\n]*(?:\n|$))*do(?=[ \t\n;]|$)/.test(input.slice(values.end + 1)))
-          structures.pop();
-        index = values.end;
-        segment = index + 1;
+      if (char === "}" && state.words.length === 0 && !state.redirectTarget && (close === "}" || close === "nofork") && state.structures.length === 0 && (heredocs !== undefined || state.heredocs.length === 0) && (close === "nofork" || (BRACE_CLOSE_AHEAD_RE.lastIndex = index + 1, BRACE_CLOSE_AHEAD_RE.test(input))))
+        return closeBashList(state, index);
+      if (char === "}")
+        return { kind: "opaque", reason: state.structures.length ? "compound-command" : "invalid-structure" };
+      const step = scanBashCommandStart(state, index, depth, context);
+      if (typeof step === "object")
+        return step;
+      if (step !== undefined) {
+        index = step;
         continue;
       }
-      if (!words.length && !hasRedirect && !compoundEnd) {
-        const definition = bashFunctionHead(input, index);
-        if (definition && !header()) {
-          index += definition.length - 1;
-          segment = index + 1;
-          continue;
-        }
-        if (!header() && (token === "if" || token === "while" || token === "until" || token === "for" || token === "select" || token === "case")) {
-          if (depth + structures.length >= MAX_SUBSTITUTION_DEPTH)
-            return { kind: "opaque", reason: "compound-command" };
-          structures.push({
-            kind: token === "select" ? "for" : token,
-            phase: ["for", "select", "case"].includes(token) ? "header" : "condition",
-            count: 0
-          });
-          index += token.length - 1;
-          segment = index + 1;
-          inList = false;
-          continue;
-        }
-        if (token && ["then", "elif", "else", "fi", "do", "done", "esac"].includes(token) && (!header() || token === "do" && structure?.phase === "do" || token === "esac" && structure?.phase === "pattern")) {
-          if (!structure || dangling)
-            return { kind: "opaque", reason: "compound-command" };
-          if (token === "then") {
-            if (structure.kind !== "if" || structure.phase !== "condition" || !structure.count)
-              return { kind: "opaque", reason: "compound-command" };
-            structure.phase = "body";
-          } else if (token === "elif" || token === "else") {
-            if (structure.kind !== "if" || structure.phase !== "body" || !structure.count || structure.sawElse)
-              return { kind: "opaque", reason: "compound-command" };
-            structure.phase = token === "elif" ? "condition" : "body";
-            structure.sawElse = token === "else";
-          } else if (token === "do") {
-            if (!["for", "while", "until"].includes(structure.kind) || !["condition", "do"].includes(structure.phase) || structure.kind !== "for" && !structure.count)
-              return { kind: "opaque", reason: "compound-command" };
-            structure.phase = "body";
-          } else {
-            if (token === "fi" && (structure.kind !== "if" || structure.phase !== "body" || !structure.count) || token === "done" && (!["for", "while", "until"].includes(structure.kind) || structure.phase !== "body" || !structure.count) || token === "esac" && (structure.kind !== "case" || structure.phase === "header"))
-              return { kind: "opaque", reason: "compound-command" };
-            structures.pop();
-            statement();
-            compoundEnd = true;
-            dangling = false;
-          }
-          structure.count = 0;
-          index += token.length - 1;
-          segment = index + 1;
-          inList = false;
-          continue;
-        }
-        if (!header() && (char === "!" && /[ \t\n]/.test(input[index + 1] ?? "") || token === "coproc" && /^coproc[ \t]+(?:[A-Za-z_][A-Za-z0-9_]*[ \t]+)?(?:[{(]|(?:if|while|until|for|case)\b)/.test(input.slice(index)) || token === "time" && /^time[ \t]+(?:-p[ \t]+)?(?:[{(]|(?:if|while|until|for|case)\b)/.test(input.slice(index)))) {
-          index += token ? token.length - 1 : 0;
-          if (token === "time")
-            index += /^[ \t]+-p\b/.exec(input.slice(index + 1))?.[0].length ?? 0;
-          if (token === "coproc")
-            index += /^[ \t]+[A-Za-z_][A-Za-z0-9_]*[ \t]+(?=[{(]|(?:if|while|until|for|case)\b)/.exec(input.slice(index + 1))?.[0].length ?? 0;
-          segment = index + 1;
-          continue;
-        }
-      }
-      if ((!words.length && !hasRedirect && !header() || structure?.kind === "for" && structure.phase === "header") && input.startsWith("((", index)) {
-        const expression = bashExpansion(input, index, depth, "arithmetic");
-        if (!expression)
-          return { kind: "opaque", reason: "invalid-structure" };
-        const failure = addSubstitutions(expression);
-        if (failure)
-          return failure;
-        commands.push(...nestedCommands.splice(0));
-        statement();
-        compoundEnd = !header();
-        dangling = false;
-        index = expression.end;
-        segment = index + 1;
-        continue;
-      }
-      if (!words.length && !hasRedirect && !header() && (char === "(" || char === "{" && /[ \t\n]/.test(input[index + 1] ?? ""))) {
-        const group = bashDelimited(input, index, depth);
-        if (!group || !group.source.trim())
-          return { kind: "opaque", reason: "invalid-structure" };
-        const result = scanBash(group.source, depth + 1, budget);
-        if (result.kind === "opaque")
-          return result;
-        commands.push(...result.commands);
-        statement();
-        compoundEnd = true;
-        dangling = false;
-        index = group.end;
-        segment = index + 1;
-        continue;
-      }
-      if (!words.length && !hasRedirect && input.startsWith("[[", index)) {
-        const expression = bashExpansion(input, index, depth, "test");
-        if (!expression)
+    }
+    if (char === "\\" && index + 1 >= input.length)
+      return { kind: "opaque", reason: "unterminated-escape" };
+    if (!state.assignmentWord && (`'"\\`.includes(char) || char === "$" && (input[index + 1] === "'" || input[index + 1] === '"')))
+      state.assignmentHeadUnsafe = true;
+    const inCasePattern = state.structures.at(-1)?.phase === "pattern";
+    const array = state.assignmentWord && /[^=]=$/.test(state.word) && (state.commandWordIndex < 0 || BASH_ASSIGNMENT_DECLARATIONS.has(state.rawWords[state.commandWordIndex]));
+    if (char === "=" && (!state.wordStarted || array) && input[index + 1] === "(") {
+      const end = scanBashNested(input, index + 2, depth, context, state.nestedCommands, ")");
+      if (typeof end === "object")
+        return end;
+      state.wordStarted = true;
+      state.word += input.slice(index, end + 1);
+      index = end;
+      state.wordEnd = index + 1;
+      continue;
+    }
+    const unit = BASH_UNIT_STARTS.includes(char) ? scanBashUnit(input, index, depth, context, state.nestedCommands, "word", !state.assignmentWord && state.commandWordIndex >= 0 && !BASH_DECLARATIONS.has(state.rawWords[0]), state) : undefined;
+    if (typeof unit === "object")
+      return unit;
+    if (unit !== undefined) {
+      state.wordStarted = true;
+      index = unit;
+      state.wordEnd = index + 1;
+      continue;
+    }
+    if (char === "[" && !inCasePattern && !state.assignmentWord && !state.assignmentHeadUnsafe && state.commandWordIndex < 0 && /^[A-Za-z_][A-Za-z0-9_]*$/.test(state.word)) {
+      const subscript = [];
+      const end = scanBashSubscript(input, index + 1, depth, context, subscript, BASH_SPANS.assignmentSubscript);
+      if (typeof end === "object")
+        return end;
+      const assign = bashOperator(input, end + 1, ["+=", "="]);
+      if (typeof assign === "object")
+        return assign;
+      if (assign) {
+        if (context.dialect === "posix" && /[$`]/.test(input.slice(index + 1, end)))
           return { kind: "opaque", reason: "invalid-structure" };
-        const failure = addSubstitutions(expression);
-        if (failure)
-          return failure;
-        commands.push(...nestedCommands.splice(0));
-        statement();
-        compoundEnd = true;
-        dangling = false;
-        index = expression.end;
-        segment = index + 1;
+        state.nestedCommands.push(...subscript);
+        state.assignmentWord = true;
+        state.word += input.slice(index, end + 1);
+        index = end;
+        state.wordEnd = index + 1;
         continue;
       }
     }
-    if (quote === "single") {
-      wordStarted = true;
-      wordEnd = index + 1;
-      if (char === "'")
-        quote = undefined;
-      else
-        word += char;
-      continue;
-    }
-    if (quote === "double") {
-      wordStarted = true;
-      if (char === '"')
-        quote = undefined;
-      else if (char === "\\" && index + 1 < input.length) {
-        const next = input[index + 1];
-        if ('$`"\\\n'.includes(next)) {
-          index++;
-          if (next !== `
-`)
-            word += next;
-        } else
-          word += char;
-      } else if (char === "$" && "({[".includes(input[index + 1] ?? "\x00") || char === "`") {
-        const substitution = bashExpansion(input, index, depth, undefined, true);
-        if (!substitution || depth >= MAX_SUBSTITUTION_DEPTH)
-          return { kind: "opaque", reason: "command-substitution" };
-        const failure = addSubstitutions(substitution);
-        if (failure)
-          return failure;
-        word += input.slice(index, substitution.end + 1);
-        index = substitution.end;
-      } else
-        word += char;
-      wordEnd = index + 1;
-      continue;
-    }
-    if (char === "$" && input[index + 1] === "'") {
-      const literal = bashAnsiQuote(input, index + 1);
-      if (!literal)
-        return { kind: "opaque", reason: "unterminated-quote" };
-      wordStarted = true;
-      if (!assignmentWord)
-        assignmentHeadUnsafe = true;
-      word += literal.value;
-      index = literal.end;
-      wordEnd = index + 1;
-      continue;
-    }
-    if (char === "$" && input[index + 1] === '"') {
-      quote = "double";
-      wordStarted = true;
-      if (!assignmentWord)
-        assignmentHeadUnsafe = true;
-      wordEnd = ++index + 1;
-      continue;
-    }
-    if (char === "'") {
-      quote = "single";
-      wordStarted = true;
-      wordEnd = index + 1;
-      if (!assignmentWord)
-        assignmentHeadUnsafe = true;
-      continue;
-    }
-    if (char === '"') {
-      quote = "double";
-      wordStarted = true;
-      wordEnd = index + 1;
-      if (!assignmentWord)
-        assignmentHeadUnsafe = true;
-      continue;
-    }
-    if (char === "\\") {
-      if (index + 1 >= input.length)
-        return { kind: "opaque", reason: "unterminated-escape" };
-      if (input[index + 1] === `
-`)
-        index++;
-      else {
-        wordStarted = true;
-        if (!assignmentWord)
-          assignmentHeadUnsafe = true;
-        word += input[++index];
-        wordEnd = index + 1;
-      }
-      continue;
-    }
-    if (char === "$" && "({[".includes(input[index + 1] ?? "\x00") || char === "`" || char === "[" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(word) && /^\[[\s\S]*?\]\+?=/.test(input.slice(index)) || char === "(" && (assignmentWord || /[?*+@!]$/.test(word))) {
-      const substitution = char === "(" ? bashExpansion(input, index, depth, assignmentWord ? "array" : "pattern") : char === "[" ? bashExpansion(input, index, depth, "subscript") : bashExpansion(input, index, depth);
-      if (!substitution || depth >= MAX_SUBSTITUTION_DEPTH)
-        return { kind: "opaque", reason: "command-substitution" };
-      const failure = addSubstitutions(substitution);
-      if (failure)
-        return failure;
-      wordStarted = true;
-      word += input.slice(index, substitution.end + 1);
-      index = substitution.end;
-      wordEnd = index + 1;
-      continue;
-    }
-    if ((char === "<" || char === ">" || char === "=" && !wordStarted) && input[index + 1] === "(") {
-      const substitution = bashDelimited(input, index + 1, depth);
-      if (!substitution || depth >= MAX_SUBSTITUTION_DEPTH)
-        return { kind: "opaque", reason: "command-substitution" };
-      const failure = addSubstitutions(substitution);
-      if (failure)
-        return failure;
-      wordStarted = true;
-      word += input.slice(index, substitution.end + 1);
-      index = substitution.end;
-      wordEnd = index + 1;
+    if (char === "(" && (array || (inCasePattern || context.dialect === "bash") && /[?*+@!]$/.test(state.word))) {
+      const mode = array ? "array" : "pattern";
+      const end = scanBashArrayOrPattern(input, index, depth + 1, context, state.nestedCommands, mode);
+      if (typeof end === "object")
+        return end;
+      if (bashCrossesHeredoc(state, index, end))
+        return { kind: "opaque", reason: "heredoc" };
+      if (array && end + 1 < input.length && !` 	
+;&|<>)`.includes(input[end + 1]))
+        return { kind: "opaque", reason: "invalid-structure" };
+      state.wordStarted = true;
+      state.word += input.slice(index, end + 1);
+      index = end;
+      state.wordEnd = index + 1;
       continue;
     }
-    if (char === "#" && !wordStarted) {
+    if (char === "#" && !state.wordStarted) {
       const newline = input.indexOf(`
 `, index);
-      if (words.length > 0 || hasRedirect) {
-        finishCommand();
-        dangling = false;
-        inList = false;
-      }
       if (newline === -1)
         break;
       index = newline - 1;
-      segment = newline;
       continue;
     }
-    const redirect = "<>&".includes(char) ? BASH_REDIRECTS.find((candidate) => input.startsWith(candidate, index)) : undefined;
-    if (redirect) {
-      hasRedirect = true;
-      if (redirectTarget)
-        invalidRedirect = true;
-      if (wordStarted && !assignmentHeadUnsafe && /^(?:\d+|\{[A-Za-z_][A-Za-z0-9_]*\})$/.test(word)) {
-        if (wordEnd < index)
-          commandEnd = wordEnd;
-        word = "";
-        wordStarted = false;
-      } else
-        finishWord();
-      if (redirectWordCount === undefined && assignmentWords.some((assignment) => !assignment)) {
-        redirectWordCount = words.length;
-        if (inList)
-          resourceEnd = commandEnd;
-      }
-      if (redirect === "<<" || redirect === "<<-") {
-        const delimiter = bashHeredocDelimiter(input, index);
-        if (!delimiter)
-          return { kind: "opaque", reason: "invalid-redirect" };
-        heredocs.push(delimiter);
-        wordEnd = delimiter.end + 1;
-        index = delimiter.end;
-        redirectTarget = false;
-        continue;
-      }
-      redirectTarget = true;
-      index += redirect.length - 1;
+    if (`<>&|;
+`.includes(char)) {
+      const step = scanBashOperatorOrSeparator(state, index, depth, context);
+      if (typeof step === "object")
+        return step;
+      index = step;
       continue;
     }
-    if (structures.at(-1)?.phase === "pattern" && (char === ")" || char === "|")) {
-      finishWord();
+    if (inCasePattern && char === ")") {
+      finishBashWord(state);
       index--;
       continue;
     }
-    if ("()".includes(char))
-      return { kind: "opaque", reason: "compound-command" };
+    if (char === ")") {
+      if (close !== ")" || state.structures.length > 0 || heredocs === undefined && state.heredocs.length > 0)
+        return { kind: "opaque", reason: "compound-command" };
+      return closeBashList(state, index);
+    }
+    if (char === "(")
+      return { kind: "opaque", reason: state.wordStarted ? "dynamic-execution" : "compound-command" };
     if (/\s/.test(char) && !` 	
 `.includes(char))
       return { kind: "opaque", reason: "invalid-structure" };
     if (char === " " || char === "\t") {
-      finishWord();
+      finishBashWord(state);
       continue;
     }
-    const next = input[index + 1];
-    const separator = char === "&" && next === "&" || char === "|" && (next === "|" || next === "&") ? char + next : char === ";" || char === "|" || char === "&" || char === `
-` ? char : undefined;
-    if (separator) {
-      const structure = structures.at(-1);
-      if (char === ";" && structure?.kind === "case" && structure.phase === "body" && (next === ";" || next === "&")) {
-        if (wordStarted || words.length || hasRedirect || compoundEnd)
-          finishCommand();
-        structure.phase = "pattern";
-        index += input.startsWith(";;&", index) ? 2 : 1;
-        segment = index + 1;
-        inList = false;
-        continue;
-      }
-      if (separator === `
-` && !wordStarted && words.length === 0 && !hasRedirect && !compoundEnd) {
-        if (heredocs.length) {
-          for (const heredoc of heredocs.splice(0)) {
-            const body = bashHeredoc(input, index + 1, heredoc);
-            if (!body)
-              return { kind: "opaque", reason: "heredoc" };
-            if (heredoc.command)
-              heredoc.command.resource = input.slice(heredoc.start, body.end).trim();
-            if (!heredoc.quoted) {
-              const expansion = bashExpansion(body.source, 0, depth, "heredoc");
-              if (!expansion)
-                return { kind: "opaque", reason: "command-substitution" };
-              const failure = addSubstitutions(expansion);
-              if (failure)
-                return failure;
-              commands.push(...nestedCommands.splice(0));
-            }
-            index = body.end;
-          }
-        }
-        segment = index + 1;
-        continue;
+    state.wordStarted = true;
+    if (char === "=" && !state.assignmentWord && !state.assignmentHeadUnsafe && /^[A-Za-z_][A-Za-z0-9_]*\+?$/.test(state.word))
+      state.assignmentWord = true;
+    bashAppend(state, char);
+    state.wordEnd = index + 1;
+  }
+  if (close)
+    return { kind: "opaque", reason: close === ")" ? "command-substitution" : "invalid-structure" };
+  if (state.heredocs.length)
+    return { kind: "opaque", reason: "heredoc" };
+  return closeBashList(state, input.length);
+}
+function scanBashOperatorOrSeparator(state, index, depth, context) {
+  const input = state.input;
+  const char = input[index];
+  const redirect = "<>&".includes(char) ? bashOperator(input, index, BASH_REDIRECTS) : undefined;
+  if (typeof redirect === "object")
+    return redirect;
+  const caseHead = state.structures.at(-1);
+  if (redirect && caseHead?.kind === "case" && caseHead.phase !== "body")
+    return { kind: "opaque", reason: "invalid-redirect" };
+  if (redirect) {
+    state.hasRedirect = true;
+    state.commandStart ??= state.wordStart;
+    if (state.redirectTarget)
+      state.invalid ??= "invalid-redirect";
+    const fdPrefix = state.wordStarted && !state.assignmentHeadUnsafe && /^(?:\d+|\{[A-Za-z_][A-Za-z0-9_]*\})$/.test(state.word);
+    if (fdPrefix) {
+      if (state.wordEnd < index)
+        state.commandEnd = state.wordEnd;
+      state.word = "";
+      state.literal = "";
+      state.output = "";
+      state.wordStarted = false;
+    }
+    if (!fdPrefix)
+      finishBashWord(state);
+    if (redirect.startsWith("&") && context.dialect === "posix")
+      state.ampersandRedirectWords ??= state.words.length;
+    if (state.redirectWordCount === undefined && state.commandWordIndex >= 0) {
+      state.redirectWordCount = state.words.length;
+      if (state.dangling)
+        state.resourceEnd = state.commandEnd;
+    }
+    if (redirect === "<<" || redirect === "<<-") {
+      const delimiter = bashHeredocDelimiter(input, index + redirect.length, redirect === "<<-");
+      if (!delimiter)
+        return { kind: "opaque", reason: "invalid-redirect" };
+      state.heredocs.push(delimiter);
+      state.wordEnd = delimiter.end + 1;
+      state.redirectTarget = false;
+      return delimiter.end;
+    }
+    state.redirectTarget = true;
+    state.hereString = redirect === "<<<";
+    return index + redirect.length - 1;
+  }
+  if (state.structures.at(-1)?.phase === "pattern" && char === "|") {
+    finishBashWord(state);
+    return index - 1;
+  }
+  const structure = state.structures.at(-1);
+  const caseBody = structure?.kind === "case" && structure.phase === "body";
+  const operator = bashOperator(input, index, caseBody ? BASH_CASE_OPERATORS : BASH_LIST_OPERATORS);
+  if (typeof operator === "object")
+    return operator;
+  const separator = operator ?? char;
+  if (caseBody && separator.startsWith(";") && separator.length > 1) {
+    if (!endBashList(state))
+      return { kind: "opaque", reason: "invalid-structure" };
+    structure.phase = "pattern";
+    structure.patternStarted = false;
+    return index + separator.length - 1;
+  }
+  if (structure?.kind === "case" && (structure.phase === "header" || structure.phase === "pattern")) {
+    if (separator !== `
+`)
+      return { kind: "opaque", reason: "compound-command" };
+    if (structure.phase === "pattern" && (state.wordStarted || state.words.length > 0))
+      return { kind: "opaque", reason: "compound-command" };
+    finishBashWord(state);
+    return readBashHeredocs(state, index, depth, context);
+  }
+  if ((structure?.kind === "for" || structure?.kind === "repeat") && (structure.phase === "header" || structure.phase === "do")) {
+    if (separator !== ";" && separator !== `
+`)
+      return { kind: "opaque", reason: "compound-command" };
+    if (structure.phase === "header" && !structure.sawIn && !state.wordStarted && state.words.length === 0)
+      return { kind: "opaque", reason: "compound-command" };
+  }
+  if (separator === `
+` && !pending(state))
+    return readBashHeredocs(state, index, depth, context);
+  finishBashCommand(state, true);
+  if (structure?.kind === "for" && structure.phase === "header")
+    structure.phase = "do";
+  state.dangling = separator !== "&" && separator !== ";" && separator !== `
+`;
+  if (separator === `
+` && state.heredocs.length)
+    return index - 1;
+  return index + separator.length - 1;
+}
+function bashCommandKey(command) {
+  return JSON.stringify([command.resource, command.words]);
+}
+function readBashHeredocs(state, index, depth, context) {
+  let end = index;
+  for (const heredoc of state.heredocs.splice(0)) {
+    const body = bashHeredoc(state.input, end + 1, heredoc);
+    if (!body)
+      return { kind: "opaque", reason: "heredoc" };
+    if (heredoc.command)
+      heredoc.command.resource = state.input.slice(heredoc.start, body.end).trim();
+    const text = heredoc.quoted ? { word: body.source, literal: body.source, output: "" } : bashText();
+    if (!heredoc.quoted) {
+      const expansion = scanBashSpan(body.source, 0, depth, context, state.commands, BASH_SPANS.heredoc, true, text);
+      if (typeof expansion === "object")
+        return expansion;
+    }
+    if (heredoc.binding)
+      bashEvaluatesExpansion(text, "deferred", context);
+    end = body.end;
+  }
+  return end;
+}
+function bashCrossesHeredoc(state, start, end) {
+  return state.heredocs.length > 0 && state.input.slice(start, end).includes(`
+`);
+}
+function scanBashCommandStart(state, index, depth, context) {
+  const input = state.input;
+  const char = input[index];
+  const structure = state.structures.at(-1);
+  if (structure?.phase === "pattern" && !structure.patternStarted && !state.words.length && char === "(") {
+    structure.patternStarted = true;
+    return index;
+  }
+  if (structure?.phase === "pattern" && char === "|") {
+    if (!state.words.length)
+      return { kind: "opaque", reason: "compound-command" };
+    finishBashWord(state);
+    structure.patternStarted = true;
+    return index;
+  }
+  if (structure?.phase === "pattern" && char === ")") {
+    if (!state.words.length)
+      return { kind: "opaque", reason: "compound-command" };
+    finishBashCommand(state);
+    structure.phase = "body";
+    structure.count = 0;
+    return index;
+  }
+  if (structure?.kind === "for" && structure.phase === "header" && char === "(" && input[index + 1] !== "(") {
+    const end = scanBashArrayOrPattern(input, index, depth + 1, context, state.nestedCommands, "array");
+    if (typeof end === "object")
+      return end;
+    if (bashCrossesHeredoc(state, index, end))
+      return { kind: "opaque", reason: "heredoc" };
+    finishBashCommand(state);
+    structure.phase = "do";
+    structure.parenthesized = true;
+    DO_AHEAD_RE.lastIndex = end + 1;
+    if (!DO_AHEAD_RE.test(input))
+      state.structures.pop();
+    return end;
+  }
+  if (structure?.kind === "repeat" && structure.phase === "do" && char !== `
+` && char !== "#" && char !== ";") {
+    TOKEN_RE.lastIndex = index;
+    if (TOKEN_RE.exec(input)?.[0] !== "do")
+      state.structures.pop();
+  }
+  const keywordStep = scanBashKeyword(state, index, depth, context);
+  if (keywordStep !== undefined)
+    return keywordStep;
+  if (structure?.kind === "for" && structure.phase === "do" && char !== `
+` && char !== "#" && char !== ";") {
+    SPACE_CONTINUATION_AHEAD_RE.lastIndex = index + 1;
+    if (char !== "{" || !SPACE_CONTINUATION_AHEAD_RE.test(input))
+      return { kind: "opaque", reason: "compound-command" };
+    state.structures.pop();
+  }
+  const atStart = atCommandStart(state);
+  const functionHead = atStart && char === "(" ? bashFunctionHeadLength(input, index) : 0;
+  if (functionHead)
+    return index + functionHead - 1;
+  if (atStart && char === "!") {
+    NEGATION_AHEAD_RE.lastIndex = index + 1;
+    if (NEGATION_AHEAD_RE.test(input))
+      return index;
+  }
+  const forHeader = structure?.kind === "for" && structure.phase === "header";
+  const compoundOpen = (atStart || forHeader) && "([".includes(char) ? bashOperator(input, index, ["((", "[["]) : undefined;
+  if (typeof compoundOpen === "object")
+    return compoundOpen;
+  if (compoundOpen === "((") {
+    if (forHeader && state.words.length > 0)
+      return { kind: "opaque", reason: "compound-command" };
+    const span = forHeader ? BASH_SPANS.forArithmetic : BASH_SPANS.arithmetic;
+    const end = scanBashArithmetic(input, index + 2, depth, context, state.commands, span);
+    if (typeof end === "number") {
+      if (bashCrossesHeredoc(state, index, end))
+        return { kind: "opaque", reason: "heredoc" };
+      if (!forHeader && context.dialect === "posix") {
+        const subshells = scanBash(input, index + 1, depth + 1, context, ")");
+        if (subshells.kind === "opaque")
+          return subshells;
+        if (subshells.end !== end)
+          return { kind: "opaque", reason: "compound-command" };
+        const seen = new Set(state.commands.map(bashCommandKey));
+        state.commands.push(...subshells.commands.filter((command) => !seen.has(bashCommandKey(command))));
       }
-      finishCommand(true);
-      if (structure?.kind === "for" && structure.phase === "header")
+      if (forHeader) {
         structure.phase = "do";
-      dangling = separator !== "&" && separator !== ";" && separator !== `
-`;
-      inList = dangling;
-      if (separator === `
-` && heredocs.length) {
-        index--;
-        continue;
+        structure.sawIn = true;
       }
-      index += separator.length - 1;
-      segment = index + 1;
-      continue;
+      if (!forHeader) {
+        bashStatement(state);
+        state.compoundEnd = true;
+      }
+      return end;
     }
-    wordStarted = true;
-    if (char === "=" && !assignmentHeadUnsafe && /^[A-Za-z_][A-Za-z0-9_]*(?:\[.*\])?\+?$/.test(word))
-      assignmentWord = true;
-    word += char;
-    wordEnd = index + 1;
+    if (end)
+      return end;
+    if (forHeader)
+      return { kind: "opaque", reason: "invalid-structure" };
   }
-  if (quote)
-    return { kind: "opaque", reason: "unterminated-quote" };
-  if (heredocs.length)
-    return { kind: "opaque", reason: "heredoc" };
-  if (wordStarted || words.length > 0 || hasRedirect) {
-    finishCommand();
-    dangling = false;
+  if (atStart && (char === "(" || char === "{" && (SPACE_CONTINUATION_AHEAD_RE.lastIndex = index + 1, SPACE_CONTINUATION_AHEAD_RE.test(input)))) {
+    const group = scanBash(input, index + 1, depth + 1, context, char === "{" ? "}" : ")", state.heredocs);
+    if (group.kind === "opaque")
+      return group;
+    if (!input.slice(index + 1, group.end).trim())
+      return { kind: "opaque", reason: "invalid-structure" };
+    state.commands.push(...group.commands);
+    bashStatement(state);
+    state.compoundEnd = true;
+    return group.end;
   }
-  if (dangling)
-    invalidStructure = true;
-  if (invalidStructure)
-    return { kind: "opaque", reason: "invalid-structure" };
-  if (invalidRedirect)
-    return { kind: "opaque", reason: "invalid-redirect" };
-  if (structures.length)
-    return { kind: "opaque", reason: "compound-command" };
-  return { kind: "scanned", commands };
+  if (atStart && compoundOpen === "[[" && (SPACE_CONTINUATION_AHEAD_RE.lastIndex = index + 2, SPACE_CONTINUATION_AHEAD_RE.test(input))) {
+    const end = scanBashConditional(input, index + 2, depth, context, state.commands);
+    if (typeof end === "object")
+      return end;
+    if (bashCrossesHeredoc(state, index, end))
+      return { kind: "opaque", reason: "heredoc" };
+    bashStatement(state);
+    state.compoundEnd = true;
+    return end;
+  }
+  return;
+}
+function scanBashKeyword(state, index, depth, context) {
+  const input = state.input;
+  const char = input[index];
+  if (!(char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char === "_"))
+    return;
+  const structure = state.structures.at(-1);
+  TOKEN_RE.lastIndex = index;
+  const token = TOKEN_RE.exec(input)?.[0];
+  const end = index + (token?.length ?? 0) - 1;
+  if (structure?.kind === "case" && structure.phase === "header" && token === "in") {
+    if (state.words.length !== 1 || state.hasRedirect)
+      return { kind: "opaque", reason: "compound-command" };
+    finishBashCommand(state);
+    structure.phase = "pattern";
+    structure.patternStarted = false;
+    return end;
+  }
+  if (structure?.kind === "for" && (structure.phase === "header" || structure.phase === "do") && !structure.sawIn && !structure.parenthesized && token === "in" && (structure.phase === "do" || state.words.length >= 1)) {
+    structure.sawIn = true;
+    structure.phase = "header";
+    return end;
+  }
+  if (structure?.phase === "pattern" && !structure.patternStarted && !state.words.length && token === "esac") {
+    state.structures.pop();
+    bashStatement(state);
+    state.compoundEnd = true;
+    return end;
+  }
+  if (structure?.kind === "for" && structure.phase === "header" && !structure.sawIn && state.words.length === 1 && !state.hasRedirect && token === "do") {
+    finishBashCommand(state);
+    structure.phase = "do";
+  }
+  const inHeader = bashInHeader(state);
+  if (token && ["then", "elif", "else", "fi", "do", "done", "esac"].includes(token) && !state.words.length && !state.redirectTarget && (!inHeader || token === "do" && structure?.phase === "do")) {
+    if (state.hasRedirect && context.dialect !== "zsh" || !endBashList(state) || !structure)
+      return { kind: "opaque", reason: "compound-command" };
+    if (token === "then") {
+      if (structure.kind !== "if" || structure.phase !== "condition" || !structure.count)
+        return { kind: "opaque", reason: "compound-command" };
+      structure.phase = "body";
+      structure.count = 0;
+      return end;
+    }
+    if (token === "elif" || token === "else") {
+      if (structure.kind !== "if" || structure.phase !== "body" || !structure.count || structure.sawElse)
+        return { kind: "opaque", reason: "compound-command" };
+      structure.phase = token === "elif" ? "condition" : "body";
+      structure.sawElse = token === "else";
+      structure.count = 0;
+      return end;
+    }
+    if (token === "do") {
+      if (!["for", "while", "until", "repeat"].includes(structure.kind) || !["condition", "do"].includes(structure.phase) || structure.kind !== "for" && structure.kind !== "repeat" && !structure.count)
+        return { kind: "opaque", reason: "compound-command" };
+      structure.phase = "body";
+      structure.count = 0;
+      return end;
+    }
+    if (token === "fi" && (structure.kind !== "if" || structure.phase !== "body" || !structure.count) || token === "done" && (!["for", "while", "until", "repeat"].includes(structure.kind) || structure.phase !== "body" || !structure.count) || token === "esac" && (structure.kind !== "case" || structure.phase === "header"))
+      return { kind: "opaque", reason: "compound-command" };
+    state.structures.pop();
+    bashStatement(state);
+    state.compoundEnd = true;
+    return end;
+  }
+  if (!atCommandStart(state))
+    return;
+  const definitionLength = bashFunctionHeadLength(input, index);
+  if (definitionLength > 0)
+    return index + definitionLength - 1;
+  if (token === "if" || token === "while" || token === "until" || token === "for" || token === "select" || token === "case" || token === "repeat" && context.dialect !== "bash") {
+    if (depth + state.structures.length >= MAX_SUBSTITUTION_DEPTH)
+      return { kind: "opaque", reason: "compound-command" };
+    state.structures.push({
+      kind: token === "select" ? "for" : token,
+      phase: ["for", "select", "case", "repeat"].includes(token) ? "header" : "condition",
+      count: 0
+    });
+    state.dangling = false;
+    return end;
+  }
+  if (token === "coproc") {
+    COPROC_AHEAD_RE.lastIndex = index;
+    const coprocMatch = COPROC_AHEAD_RE.exec(input)?.[0];
+    if (coprocMatch)
+      return index + coprocMatch.length - 1;
+  }
+  if (token === "time") {
+    TIME_AHEAD_RE.lastIndex = index;
+    const timeMatch = TIME_AHEAD_RE.exec(input)?.[0];
+    if (timeMatch)
+      return index + timeMatch.length - 1;
+  }
+  return;
 }
-function bashFunctionHead(input, start) {
-  return /^(?!if(?:[ \t]|\\\n)*\()(?:function[ \t]+(?:\\\n[ \t]*)*[A-Za-z_][A-Za-z0-9_.:-]*(?:(?:[ \t]|\\\n)*\([ \t]*\))?|(?:[A-Za-z_][A-Za-z0-9_.:-]*(?:[ \t]|\\\n)*)?\([ \t]*\))(?:[ \t\n]|\\\n|#[^\n]*(?:\n|$))*(?=[{(]|\[\[(?=[ \t\n])|(?:if|while|until|for|select|case)[ \t\n])/.exec(input.slice(start))?.[0];
+function bashFunctionHeadLength(input, start) {
+  FUNCTION_HEAD_RE.lastIndex = start;
+  const head = FUNCTION_HEAD_RE.exec(input);
+  if (!head || (head[1] ? !head[2] : !head[3] || BASH_NON_FUNCTION_KEYWORDS.has(head[2] ?? "")))
+    return 0;
+  FUNCTION_BODY_RE.lastIndex = start + head[0].length;
+  return FUNCTION_BODY_RE.test(input) ? head[0].length - head[4].length : 0;
 }
-function bashDelimited(input, start, depth) {
+var BASH_SPANS = {
+  double: { close: '"', reject: "", mode: "quoted" },
+  heredoc: { reject: "", mode: "quoted" },
+  arithmetic: { open: "(", close: ")", reject: ";#}", mode: "arithmetic" },
+  forArithmetic: { open: "(", close: ")", reject: "#}", mode: "arithmetic" },
+  bracketArithmetic: { close: "]", reject: `;|&<>()[
+'"\\#`, mode: "arithmetic" },
+  subscript: { open: "[", close: "]", reject: '"}', mode: "arithmetic" },
+  quotedSubscript: { open: "[", close: "]", reject: '"', mode: "quoted" },
+  assignmentSubscript: { open: "[", close: "]", reject: ` 	
+\r\v\f;&|<>()`, mode: "arithmetic" },
+  arithmeticQuote: { close: "'", reject: '()[];"}', mode: "quoted" },
+  arithmeticDouble: { close: '"', reject: "()[];}", mode: "quoted" },
+  parameterQuote: { close: "'", reject: '"}[]', mode: "quoted" }
+};
+function scanBashUnit(input, index, depth, context, commands, mode, allowBracket, text) {
+  const char = input[index];
+  const next = input[index + 1] ?? "\x00";
+  if (char === "\\") {
+    if (mode === "quoted" && !'$`"\\\n'.includes(next))
+      return;
+    if (text && next !== `
+`)
+      bashAppend(text, input.slice(index + 1, index + 2));
+    return index + 1;
+  }
+  if (char === "$" && context.dialect !== "bash" && zshEvaluates(input, index))
+    return { kind: "opaque", reason: "dynamic-execution" };
+  if (char === "$" && context.dialect !== "bash" && (mode === "word" || mode === "quoted") && (ZSH_SUBSCRIPT_RE.lastIndex = index, ZSH_SUBSCRIPT_RE.test(input))) {
+    const bracket = ZSH_SUBSCRIPT_RE.lastIndex;
+    const subscript = bashText();
+    const span = mode === "quoted" ? BASH_SPANS.quotedSubscript : BASH_SPANS.subscript;
+    const end = scanBashSpan(input, bracket, depth, context, commands, span, false, subscript);
+    if (typeof end === "object")
+      return end;
+    if (bashEvaluatesExpansion(subscript, "arithmetic", context))
+      return { kind: "opaque", reason: "dynamic-execution" };
+    if (text)
+      text.word += `${input.slice(index, bracket)}${subscript.word}]`;
+    return end;
+  }
+  const opener = char === "$" ? bashOperator(input, index, ["$$", "$((", "$(", "${", "$[", "$'", '$"']) : mode === "word" && (char === "<" || char === ">") ? bashOperator(input, index, [`${char}(`]) : undefined;
+  if (typeof opener === "object")
+    return opener;
+  if (opener === "$$") {
+    LINE_CONTINUATION_RE.lastIndex = index + 2;
+    const quoteStart = LINE_CONTINUATION_RE.exec(input) ? LINE_CONTINUATION_RE.lastIndex : index + 2;
+    if (input[quoteStart] === "'") {
+      const nextQuote = input.indexOf("'", quoteStart + 1);
+      if (nextQuote < 0)
+        return { kind: "opaque", reason: "unterminated-quote" };
+      if (input.slice(quoteStart + 1, nextQuote).includes("\\") && input.includes("'", nextQuote + 1))
+        return { kind: "opaque", reason: "unterminated-quote" };
+    }
+    if (text)
+      text.word += "$$";
+    return index + 1;
+  }
+  if (mode === "word" && opener === "$'") {
+    const quote = bashAnsiQuote(input, index + 1);
+    if (!quote)
+      return { kind: "opaque", reason: "unterminated-quote" };
+    const firstQuote = input.indexOf("'", index + 2);
+    if (quote.end !== firstQuote && (context.dialect !== "bash" && index >= 2 && input[index - 2] === "$" || context.dialect === "posix" && (input.indexOf("'", firstQuote + 1) < quote.end || /[#"\n]|\\'/.test(input.slice(firstQuote + 1)))))
+      return { kind: "opaque", reason: "unterminated-quote" };
+    if (text)
+      bashAppend(text, quote.value);
+    return quote.end;
+  }
+  if (mode === "arithmetic" && opener === "$'") {
+    const quote = bashAnsiQuote(input, index + 1);
+    if (!quote || quote.end !== input.indexOf("'", index + 2) || /[()[\];"}]/.test(quote.value))
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (text)
+      bashAppend(text, quote.value);
+    return scanBashSpan(input, index + 2, depth, context, commands, BASH_SPANS.arithmeticQuote, allowBracket, text);
+  }
+  if (mode === "word" && char === "'") {
+    const end = input.indexOf("'", index + 1);
+    if (end < 0)
+      return { kind: "opaque", reason: "unterminated-quote" };
+    if (text)
+      bashAppend(text, input.slice(index + 1, end));
+    return end;
+  }
+  if (mode === "arithmetic" && char === "'")
+    return scanBashSpan(input, index + 1, depth, context, commands, BASH_SPANS.arithmeticQuote, allowBracket, text);
+  if (mode === "word" && opener === '$"')
+    return scanBashSpan(input, index + 2, depth, context, commands, BASH_SPANS.double, allowBracket, text);
+  if (mode !== "quoted" && char === '"') {
+    const span = mode === "arithmetic" ? BASH_SPANS.arithmeticDouble : BASH_SPANS.double;
+    return scanBashSpan(input, index + 1, depth, context, commands, span, allowBracket, text);
+  }
+  const end = opener === "<(" || opener === ">(" ? scanBashNested(input, index + 2, depth, context, commands, ")") : opener && opener !== "$'" && opener !== '$"' || char === "`" ? scanBashDollarOrBacktick(input, index, depth, context, commands, mode !== "word", allowBracket, text) : undefined;
+  if (end === undefined && char === "$" && /[A-Za-z_0-9@*#?$!-]/.test(next)) {
+    if (text)
+      text.word += "$";
+    return index;
+  }
+  if (text && typeof end === "number")
+    text.word += input.slice(index, end + 1);
+  return end;
+}
+function zshEvaluates(input, index) {
+  let at = index + 1;
+  if (input.startsWith("{\\\n", at))
+    return true;
+  if (input[at] === "{" && input[at + 1] === "(") {
+    ZSH_SAFE_FLAGS_RE.lastIndex = index;
+    if (!ZSH_SAFE_FLAGS_RE.test(input))
+      return true;
+    at = ZSH_SAFE_FLAGS_RE.lastIndex;
+  }
+  if (input[at] === "{")
+    at++;
+  ZSH_GLOB_MODIFIER_RE.lastIndex = at;
+  return ZSH_GLOB_MODIFIER_RE.test(input);
+}
+function bashAppend(text, value) {
+  text.word += value;
+  text.literal += value;
+}
+function bashEvaluatesExpansion(text, evaluation, context) {
+  const combined = `${text.literal} ${text.output}`;
+  const hasExpansion = BASH_EXPANSION_RE.test(combined);
+  const hasEscape = BASH_ESCAPE_RE.test(text.literal);
+  if (hasExpansion || hasEscape || /[$`]/.test(text.literal))
+    context.boundDollar = true;
+  if (hasExpansion || hasEscape || /[({`]/.test(text.literal))
+    context.boundOpen = true;
+  if (evaluation === "deferred")
+    return false;
+  if (evaluation === "arithmetic" ? /[A-Za-z_]|(?:\$(?![?#!-]|\$(?!\[)))/.test(text.word) : text.word.includes("$") || combined.includes("["))
+    context.variableSink = true;
+  if (evaluation === "arithmetic")
+    return hasExpansion;
+  return combined.includes("[") && hasExpansion;
+}
+function bashText() {
+  return { word: "", literal: "", output: "" };
+}
+function scanBashSubscript(input, start, depth, context, commands, span = BASH_SPANS.subscript) {
+  const text = bashText();
+  const end = scanBashSpan(input, start, depth, context, commands, span, false, text);
+  if (typeof end === "number" && bashEvaluatesExpansion(text, "arithmetic", context))
+    return { kind: "opaque", reason: "dynamic-execution" };
+  return end;
+}
+function scanBashSpan(input, start, depth, context, commands, span, allowBracket, text) {
+  let nesting = 0;
+  for (let index = start;index < input.length; index++) {
+    if (--context.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
+    const char = input[index];
+    if (char === span.close && !nesting)
+      return index;
+    if (span.reject.includes(char) && !(char === "#" && /[\d$]/.test(input[index - 1] ?? "")))
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (char === span.open && ++nesting + depth > MAX_SUBSTITUTION_DEPTH)
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (char === span.close)
+      nesting--;
+    const unit = char === span.open || char === span.close ? undefined : scanBashUnit(input, index, depth, context, commands, span.mode, allowBracket, text);
+    if (typeof unit === "object")
+      return unit;
+    if (unit !== undefined)
+      index = unit;
+    else if (char === "\\" && (input[index + 1] === span.open || input[index + 1] === span.close)) {
+      if (text)
+        bashAppend(text, input.slice(index, index + 2));
+      index++;
+    } else if (text)
+      bashAppend(text, char);
+  }
+  return span.close ? { kind: "opaque", reason: "unterminated-quote" } : input.length;
+}
+function scanBashNested(input, start, depth, context, commands, close, text) {
+  const nested = scanBash(input, start, depth + 1, context, close, undefined, text);
+  if (nested.kind === "opaque")
+    return nested;
+  commands.push(...nested.commands);
+  return nested.end;
+}
+function bashOperator(input, index, operators) {
+  let text = "";
+  for (let cursor = index;text.length < 3 && cursor < input.length; cursor++) {
+    if (input.startsWith("\\\n", cursor))
+      cursor++;
+    else
+      text += input[cursor];
+  }
+  const operator = operators.find((candidate) => text.startsWith(candidate));
+  if (operator && !input.startsWith(operator, index))
+    return { kind: "opaque", reason: "invalid-structure" };
+  return operator;
+}
+function scanBashDollarOrBacktick(input, start, depth, context, commands, quoted, allowBracket, text) {
   if (depth >= MAX_SUBSTITUTION_DEPTH)
+    return { kind: "opaque", reason: "command-substitution" };
+  if (input[start] === "`")
+    return scanBashBacktick(input, start, depth + 1, context, commands, quoted, text);
+  if (input.startsWith("$((", start)) {
+    const end = scanBashArithmetic(input, start + 3, depth + 1, context, commands, BASH_SPANS.arithmetic);
+    if (end !== undefined)
+      return end;
+  }
+  if (input.startsWith("$(", start))
+    return scanBashNested(input, start + 2, depth, context, commands, ")", text);
+  NOFORK_OPEN_RE.lastIndex = start;
+  const nofork = NOFORK_OPEN_RE.exec(input);
+  if (nofork)
+    return scanBashNested(input, start + nofork[0].length, depth, context, commands, "nofork", text);
+  if (input.startsWith("${", start)) {
+    const parameter = bashText();
+    const end = scanBashParameter(input, start + 2, depth + 1, context, commands, quoted, parameter);
+    if (/^(?:\\\n)*!/.test(input.slice(start + 2))) {
+      context.variableSink = true;
+      if (bashEvaluatesExpansion(parameter, "binding", context))
+        return { kind: "opaque", reason: "dynamic-execution" };
+    }
+    if (text) {
+      text.literal += parameter.literal;
+      text.output += parameter.output;
+    }
+    return end;
+  }
+  if (!allowBracket && context.dialect === "posix")
+    return { kind: "opaque", reason: "command-substitution" };
+  const expression = bashText();
+  const end = scanBashSpan(input, start + 2, depth + 1, context, commands, BASH_SPANS.bracketArithmetic, true, expression);
+  if (typeof end === "number" && bashEvaluatesExpansion(expression, "arithmetic", context))
+    return { kind: "opaque", reason: "dynamic-execution" };
+  return end;
+}
+function scanBashArithmetic(input, start, depth, context, commands, span) {
+  const arithmetic = [];
+  const text = bashText();
+  const end = scanBashSpan(input, start, depth, context, arithmetic, span, true, text);
+  if (typeof end === "object")
+    return { kind: "opaque", reason: "invalid-structure" };
+  const close = bashOperator(input, end, ["))"]);
+  if (typeof close === "object")
+    return close;
+  if (!close)
     return;
-  const close = input[start] === "{" ? "}" : ")";
-  const cases = [];
-  const heredocs = [];
-  let commandStart = true;
+  if (bashEvaluatesExpansion(text, "arithmetic", context))
+    return { kind: "opaque", reason: "dynamic-execution" };
+  commands.push(...arithmetic);
+  return end + 1;
+}
+function scanBashBacktick(input, start, depth, context, commands, quoted, text) {
+  let source = "";
   for (let index = start + 1;index < input.length; index++) {
-    const char = input[index];
-    if (char === " " || char === "\t")
-      continue;
-    if (char === "\\") {
-      if (input[index + 1] !== `
-`)
-        commandStart = false;
+    if (--context.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (input[index] === "`") {
+      const inner = scanBash(source, 0, depth, context, undefined, undefined, text);
+      if (inner.kind === "opaque")
+        return { kind: "opaque", reason: "command-substitution" };
+      commands.push(...inner.commands);
+      return index;
+    }
+    const next = input[index + 1] ?? "\x00";
+    if (input[index] === "\\" && ("$`\\\n".includes(next) || quoted && next === '"')) {
       index++;
+      if (next !== `
+`)
+        source += next;
       continue;
     }
-    if (char === "'" || char === '"' || char === "`" || char === "$" && `({['"`.includes(input[index + 1] ?? "\x00")) {
-      commandStart = false;
-      if (char === "'" || input.startsWith("$'", index)) {
-        const end = char === "'" ? input.indexOf("'", index + 1) : bashAnsiQuote(input, index + 1)?.end;
-        if (end === undefined || end < 0)
-          return;
-        index = end;
-        continue;
+    source += input[index];
+  }
+  return { kind: "opaque", reason: "command-substitution" };
+}
+function scanBashParameter(input, start, depth, context, commands, quoted, text) {
+  PARAMETER_PREFIX_RE.lastIndex = start;
+  const nameStart = PARAMETER_PREFIX_RE.exec(input) ? PARAMETER_PREFIX_RE.lastIndex : start;
+  PARAMETER_NAME_RE.lastIndex = nameStart;
+  let colon = PARAMETER_NAME_RE.test(input) ? PARAMETER_NAME_RE.lastIndex : -1;
+  const name = colon > nameStart ? input.slice(nameStart, colon).replace(/\\\n/g, "") : "";
+  if (context.dialect !== "bash" && (/^(?:READ)?NULLCMD$/.test(name) || /^(?:(?:dis_)?(?:functions|[gs]?aliases)|options|commands)$/.test(name) && "[=:".includes(input[colon] ?? "")))
+    return { kind: "opaque", reason: "dynamic-execution" };
+  if (name === "PS4")
+    context.variableSink = true;
+  let evaluation;
+  let wordOffset = 0;
+  let literalOffset = 0;
+  for (let index = start;index < input.length; index++) {
+    if (--context.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
+    const char = input[index];
+    if (char === "}") {
+      if (evaluation && bashEvaluatesExpansion({ word: text.word.slice(wordOffset), literal: text.literal.slice(literalOffset), output: text.output }, evaluation, context))
+        return { kind: "opaque", reason: "dynamic-execution" };
+      return index;
+    }
+    if (index === colon && !evaluation) {
+      if (char === ":" && !"-=?+".includes(input[index + 1] ?? ""))
+        evaluation = "arithmetic";
+      if (char === "=" || char === ":" && input[index + 1] === "=")
+        evaluation = "deferred";
+      if (evaluation) {
+        wordOffset = text.word.length;
+        literalOffset = text.literal.length;
       }
-      const nested = char === '"' || input.startsWith('$"', index) ? bashExpansion(input, index + (char === "$" ? 1 : 0), depth + 1, "double") : bashExpansion(input, index, depth + 1);
-      if (!nested)
-        return;
-      index = nested.end;
-      continue;
     }
-    const boundary = index === start + 1 || /[ \t\n;|&(){}]/.test(input[index - 1]);
-    const definition = commandStart && boundary ? bashFunctionHead(input, index) : undefined;
-    if (definition) {
-      index += definition.length - 1;
+    if (char === "@") {
+      PARAMETER_PROMPT_RE.lastIndex = index;
+      if (PARAMETER_PROMPT_RE.test(input))
+        return { kind: "opaque", reason: "dynamic-execution" };
+    }
+    if (!quoted && context.dialect !== "bash" && char === "(" && index > start)
+      return { kind: "opaque", reason: "dynamic-execution" };
+    if (quoted && char === "'" && input[index - 1] === "$") {
+      const ansi = bashAnsiQuote(input, index);
+      if (!ansi)
+        return { kind: "opaque", reason: "unterminated-quote" };
+      text.literal += ansi.value;
+    }
+    const subscript = index === colon && char === "[";
+    const unit = subscript ? scanBashSubscript(input, index + 1, depth, context, commands) : quoted && char === "'" ? scanBashSpan(input, index + 1, depth, context, commands, BASH_SPANS.parameterQuote, false, text) : quoted && char === '"' ? scanBashSpan(input, index + 1, depth, context, commands, BASH_SPANS.double, false, text) : scanBashUnit(input, index, depth, context, commands, quoted ? "quoted" : "word", false, text);
+    if (typeof unit === "object")
+      return unit;
+    if (quoted && unit !== undefined && input.startsWith("$(", index) && input.slice(index, unit + 1).includes("}"))
+      return { kind: "opaque", reason: "command-substitution" };
+    if (subscript || index === nameStart && input.startsWith("${", index) && unit !== undefined) {
+      LINE_CONTINUATION_RE.lastIndex = Number(unit) + 1;
+      colon = LINE_CONTINUATION_RE.exec(input) ? LINE_CONTINUATION_RE.lastIndex : Number(unit) + 1;
+    }
+    if (unit !== undefined)
+      index = unit;
+    else
+      bashAppend(text, char);
+  }
+  return { kind: "opaque", reason: "command-substitution" };
+}
+function scanBashConditional(input, start, depth, context, commands) {
+  const words = [];
+  let text = bashText();
+  let wordStarted = false;
+  let hasWord = false;
+  let parenDepth = 0;
+  let patternParenDepth = 0;
+  const flushWord = () => {
+    if (!hasWord)
+      return;
+    words.push(text);
+    text = bashText();
+    hasWord = false;
+  };
+  for (let index = start;index < input.length; index++) {
+    if (--context.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
+    const char = input[index];
+    if (char === "\\" && input[index + 1] === `
+`) {
+      index++;
       continue;
     }
-    if (char === "#" && boundary) {
+    if (!wordStarted)
+      flushWord();
+    const close = !wordStarted && char === "]" ? bashOperator(input, index, ["]]"]) : undefined;
+    if (typeof close === "object")
+      return close;
+    if (close) {
+      BRACE_CLOSE_AHEAD_RE.lastIndex = index + 2;
+      if (BRACE_CLOSE_AHEAD_RE.test(input)) {
+        if (parenDepth !== 0)
+          return { kind: "opaque", reason: "invalid-structure" };
+        const evaluated = words.some((word, at) => words[at - 1]?.word === "-v" && bashEvaluatesExpansion(word, "binding", context) || (context.dialect !== "bash" && words[at - 1]?.word === "-t" || BASH_ARITHMETIC_COMPARISONS.has(words[at - 1]?.word ?? "") || BASH_ARITHMETIC_COMPARISONS.has(words[at + 1]?.word ?? "")) && bashEvaluatesExpansion(word, "arithmetic", context));
+        if (evaluated)
+          return { kind: "opaque", reason: "dynamic-execution" };
+        return index + 1;
+      }
+    }
+    if (!wordStarted && char === "#") {
       const newline = input.indexOf(`
 `, index);
       if (newline < 0)
-        return;
-      index = newline - 1;
-      continue;
-    }
-    if (input.startsWith("<<<", index)) {
-      index += 2;
+        return { kind: "opaque", reason: "invalid-structure" };
+      index = newline;
       continue;
     }
-    if (input.startsWith("<<", index)) {
-      const delimiter = bashHeredocDelimiter(input, index);
-      if (!delimiter)
-        return;
-      heredocs.push(delimiter);
-      index = delimiter.end;
+    if (char === " " || char === "\t" || char === `
+`) {
+      if (!patternParenDepth)
+        wordStarted = false;
       continue;
     }
-    if (char === `
-` && heredocs.length) {
-      for (const heredoc of heredocs.splice(0)) {
-        const body = bashHeredoc(input, index + 1, heredoc);
-        if (!body)
-          return;
-        index = body.end;
+    if (char === ";")
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (char === "(" || char === ")") {
+      if (char === ")" && parenDepth === 0)
+        return { kind: "opaque", reason: "invalid-structure" };
+      const inPattern = patternParenDepth > 0 || char === "(" && ["=", "==", "!=", "=~"].includes(words.at(-1)?.word ?? "");
+      parenDepth += char === "(" ? 1 : -1;
+      if (inPattern) {
+        patternParenDepth += char === "(" ? 1 : -1;
+        wordStarted = true;
+        hasWord = true;
+        bashAppend(text, char);
+        continue;
       }
-      commandStart = true;
+      flushWord();
+      words.push({ word: char, literal: "", output: "" });
+      wordStarted = false;
       continue;
     }
-    const token = boundary ? /^[A-Za-z_][A-Za-z0-9_]*(?=[ \t\n;()<>]|$)/.exec(input.slice(index))?.[0] : undefined;
-    if (token === "case" && commandStart)
-      cases.push("header");
-    if (token === "in" && cases.at(-1) === "header")
-      cases[cases.length - 1] = "pattern";
-    if (token === "esac" && (commandStart || cases.at(-1) === "pattern"))
-      cases.pop();
-    if (token) {
-      commandStart = commandStart && ["if", "while", "until", "then", "elif", "else", "do"].includes(token);
-      index += token.length - 1;
-      continue;
-    }
-    if (cases.length && char === ";" && /[;&]/.test(input[index + 1] ?? ""))
-      cases[cases.length - 1] = "pattern";
-    if (cases.at(-1) === "pattern" && char === "(")
-      continue;
-    if (cases.at(-1) === "pattern" && char === ")") {
-      cases[cases.length - 1] = "body";
-      commandStart = true;
+    const unit = scanBashUnit(input, index, depth, context, commands, "word", true, text);
+    if (typeof unit === "object")
+      return unit;
+    if (unit !== undefined)
+      index = unit;
+    if (unit === undefined && !patternParenDepth && "&|<>".includes(char)) {
+      flushWord();
+      words.push({ word: char, literal: "", output: "" });
+      wordStarted = false;
       continue;
     }
-    if (input.startsWith("((", index)) {
-      const nested = bashExpansion(input, index, depth + 1, "arithmetic");
-      if (!nested)
-        return;
-      index = nested.end;
-      commandStart = false;
-      continue;
-    }
-    if (char === "(" || char === "{" && boundary && /[ \t\n]/.test(input[index + 1] ?? "")) {
-      const nested = bashDelimited(input, index, depth + 1);
-      if (!nested)
-        return;
-      index = nested.end;
-      commandStart = false;
-      continue;
-    }
-    if (char === close && (close === ")" || boundary))
-      return { source: input.slice(start + 1, index), end: index };
-    if (/[\n;&|]/.test(char))
-      commandStart = true;
-    else if (!/[ \t]/.test(char))
-      commandStart = false;
+    wordStarted = true;
+    hasWord = true;
+    if (unit === undefined)
+      bashAppend(text, char);
   }
+  return { kind: "opaque", reason: "invalid-structure" };
 }
-function bashExpansion(input, start, depth, mode, quoted = false) {
-  if (depth >= MAX_SUBSTITUTION_DEPTH)
-    return;
-  if (!mode && input[start] === "`") {
-    let source = "";
-    for (let index = start + 1;index < input.length; index++) {
-      if (input[index] === "`")
-        return { source, end: index };
-      if (input[index] === "\\" && "$`\\\n".includes(input[index + 1] ?? "\x00")) {
-        if (input[++index] !== `
-`)
-          source += input[index];
-        continue;
-      }
-      source += input[index];
-    }
-    return;
-  }
-  if (!mode && input.startsWith("$(", start) && !input.startsWith("$((", start))
-    return bashDelimited(input, start + 1, depth);
-  if (!mode && /^\$\{[ \t\n|]/.test(input.slice(start))) {
-    const nested = bashDelimited(input, start + 1, depth);
-    if (!nested)
-      return;
-    return { ...nested, source: nested.source.startsWith("|") ? nested.source.slice(1) : nested.source };
-  }
-  const kind = mode ?? (input[start + 1] === "{" ? "parameter" : input[start + 1] === "[" ? "subscript" : "arithmetic");
-  const arithmetic = ["arithmetic", "arithmetic-group", "subscript"].includes(kind);
-  const offset = mode ? kind === "heredoc" ? 0 : kind === "arithmetic" || kind === "test" ? 2 : 1 : kind === "arithmetic" ? 3 : 2;
-  const close = kind === "heredoc" ? undefined : kind === "double" ? '"' : kind === "parameter" ? "}" : kind === "subscript" ? "]" : kind === "test" ? "]]" : kind === "arithmetic" ? "))" : ")";
-  const substitutions = [];
-  for (let index = start + offset;index < input.length; index++) {
+function scanBashArrayOrPattern(input, start, depth, context, commands, mode) {
+  if (depth > MAX_SUBSTITUTION_DEPTH)
+    return { kind: "opaque", reason: "command-substitution" };
+  const text = mode === "array" ? bashText() : undefined;
+  let wordStarted = false;
+  for (let index = start + 1;index < input.length; index++) {
+    if (--context.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
     const char = input[index];
-    if (close && input.startsWith(close, index))
-      return { source: input.slice(start + offset, index), end: index + close.length - 1, substitutions };
-    if (char === "\\") {
-      if (kind !== "heredoc" && kind !== "double" || '$`\\\n"'.includes(input[index + 1] ?? "\x00"))
-        index++;
+    if (char === "\\" && input[index + 1] === `
+`) {
+      index++;
       continue;
     }
-    if ((char === "'" || input.startsWith("$'", index)) && kind !== "double" && kind !== "heredoc" && !arithmetic && !(kind === "parameter" && quoted)) {
-      const end = char === "'" ? input.indexOf("'", index + 1) : bashAnsiQuote(input, index + 1)?.end;
-      if (end === undefined || end < 0)
-        return;
-      index = end;
-      continue;
+    if (text && (char === ")" || char === " " || char === "\t" || char === `
+`)) {
+      bashEvaluatesExpansion(text, "deferred", context);
+      text.literal = "";
+      text.output = "";
     }
-    if (char === '"' && kind !== "heredoc") {
-      const nested = bashExpansion(input, index, depth + 1, "double");
-      if (!nested)
-        return;
-      substitutions.push(...nested.substitutions);
-      index = nested.end;
-      continue;
-    }
-    if (char === "`" || char === "$" && "({[".includes(input[index + 1] ?? "\x00")) {
-      const nested = bashExpansion(input, index, depth + 1, undefined, kind === "double" || quoted);
-      if (!nested)
-        return;
-      substitutions.push(...nested.substitutions ?? [nested.source]);
-      index = nested.end;
-      continue;
-    }
-    if ((kind === "array" && "<>=".includes(char) || kind === "test" && "<>".includes(char)) && input[index + 1] === "(") {
-      const nested = bashDelimited(input, index + 1, depth + 1);
-      if (!nested)
-        return;
-      substitutions.push(nested.source);
-      index = nested.end;
+    if (char === ")")
+      return index;
+    if (mode === "array" && !wordStarted && char === "#") {
+      const newline = input.indexOf(`
+`, index);
+      if (newline < 0)
+        return { kind: "opaque", reason: "command-substitution" };
+      index = newline;
       continue;
     }
-    if ((arithmetic || kind === "array" || kind === "pattern") && (char === "(" || char === "[") || kind === "parameter" && char === "[" && /^[!#]?[A-Za-z_][A-Za-z0-9_]*$/.test(input.slice(start + offset, index))) {
-      const nested = bashExpansion(input, index, depth + 1, char === "[" ? "subscript" : arithmetic ? "arithmetic-group" : kind);
-      if (!nested)
-        return;
-      substitutions.push(...nested.substitutions);
-      index = nested.end;
+    if (char === " " || char === "\t" || mode === "array" && char === `
+`) {
+      wordStarted = false;
       continue;
     }
-    if (!mode && kind === "arithmetic" && char === ";")
-      return;
+    if (char === `
+` || char === ";" || char === "&" || mode === "array" && "|(".includes(char))
+      return { kind: "opaque", reason: "command-substitution" };
+    wordStarted = true;
+    const unit = mode === "array" && char === "=" && input[index + 1] === "(" ? scanBashNested(input, index + 2, depth, context, commands, ")") : char === "(" ? scanBashArrayOrPattern(input, index, depth + 1, context, commands, mode) : char === "[" ? scanBashSubscript(input, index + 1, depth, context, commands) : scanBashUnit(input, index, depth, context, commands, "word", false, text);
+    if (typeof unit === "object")
+      return unit;
+    if (unit !== undefined)
+      index = unit;
+    else if (text)
+      text.literal += char;
   }
-  if (kind === "heredoc")
-    return { source: input.slice(start), end: input.length - 1, substitutions };
+  return { kind: "opaque", reason: "command-substitution" };
 }
 function bashAnsiQuote(input, start) {
   let value = "";
@@ -731,58 +1286,45 @@ function bashAnsiQuote(input, start) {
       continue;
     }
     const escaped = input[++index];
-    const simple = {
-      a: "\x07",
-      b: "\b",
-      e: "\x1B",
-      E: "\x1B",
-      f: "\f",
-      n: `
-`,
-      r: "\r",
-      t: "\t",
-      v: "\v",
-      "\\": "\\",
-      "'": "'",
-      '"': '"',
-      "?": "?"
-    };
-    if (escaped in simple)
-      value += simple[escaped];
-    else if (escaped === "c" && index + 1 < input.length)
-      value += String.fromCharCode(input[++index].toUpperCase().charCodeAt(0) & 31);
-    else {
-      const digits = escaped === "x" ? /^[\da-fA-F]{1,2}/.exec(input.slice(index + 1))?.[0] : escaped === "u" ? /^[\da-fA-F]{1,4}/.exec(input.slice(index + 1))?.[0] : escaped === "U" ? /^[\da-fA-F]{1,8}/.exec(input.slice(index + 1))?.[0] : /[0-7]/.test(escaped ?? "") ? /^[0-7]{1,3}/.exec(input.slice(index))?.[0] : undefined;
-      if (!digits)
-        value += `\\${escaped}`;
-      else {
-        const octal = /[0-7]/.test(escaped);
-        const point = parseInt(digits, octal ? 8 : 16);
-        value += point <= 1114111 ? String.fromCodePoint(point) : "";
-        index += digits.length - (octal ? 1 : 0);
-      }
+    if (escaped === undefined)
+      return;
+    if (escaped in BASH_ANSI_ESCAPES) {
+      value += BASH_ANSI_ESCAPES[escaped];
+      continue;
     }
+    const digits = escaped === "x" ? /^[\da-fA-F]{1,2}/.exec(input.slice(index + 1, index + 3))?.[0] : /[0-7]/.test(escaped) ? /^[0-7]{1,3}/.exec(input.slice(index, index + 3))?.[0] : undefined;
+    if (!digits)
+      return;
+    const octal = /[0-7]/.test(escaped);
+    const point = parseInt(digits, octal ? 8 : 16);
+    if (point === 0)
+      return;
+    value += String.fromCodePoint(point);
+    index += digits.length - (octal ? 1 : 0);
   }
 }
-function bashHeredocDelimiter(input, start) {
-  const tabs = input[start + 2] === "-";
+function bashHeredocDelimiter(input, start, tabs) {
   let delimiter = "";
+  let dashDelimiter;
   let quoted = false;
   let quote;
   let end = start;
   let started = false;
-  for (let index = start + (tabs ? 3 : 2);index < input.length; index++) {
+  for (let index = start;index < input.length; index++) {
     const char = input[index];
     if (!started && /[ \t]/.test(char))
       continue;
     if (!started && char === "#")
       return;
     if (!quote && /[ \t\n;&|()<>]/.test(char))
-      return started ? { delimiter, quoted, tabs, end } : undefined;
+      return started ? { delimiter, dashDelimiter, quoted, tabs, end } : undefined;
+    if (!quote && char === "$" && input.startsWith("\\\n", index + 1))
+      return;
     if (!quote && input.startsWith("$'", index)) {
       const literal = bashAnsiQuote(input, index + 1);
-      if (!literal)
+      if (!literal || literal.end !== input.indexOf("'", index + 2))
         return;
+      dashDelimiter = `${dashDelimiter ?? delimiter}$${input.slice(index + 2, literal.end)}`;
       delimiter += literal.value;
       quoted = true;
       started = true;
@@ -790,13 +1332,8 @@ function bashHeredocDelimiter(input, start) {
       end = index;
       continue;
     }
-    if (!quote && input.startsWith('$"', index)) {
-      quote = '"';
-      quoted = true;
-      started = true;
-      end = ++index;
-      continue;
-    }
+    if (!quote && input.startsWith('$"', index))
+      return;
     if (char === quote) {
       quote = undefined;
       end = index;
@@ -814,7 +1351,10 @@ function bashHeredocDelimiter(input, start) {
       if (!quote || '$`"\\'.includes(next)) {
         quoted = true;
         started = true;
-        delimiter += input[++index];
+        const escaped = input[++index];
+        if (dashDelimiter !== undefined)
+          dashDelimiter += escaped;
+        delimiter += escaped;
         end = index;
         continue;
       }
@@ -826,31 +1366,47 @@ function bashHeredocDelimiter(input, start) {
       end = index;
       continue;
     }
+    if (dashDelimiter !== undefined)
+      dashDelimiter += char;
     delimiter += char;
     started = true;
     end = index;
   }
   if (started && !quote)
-    return { delimiter, quoted, tabs, end };
+    return { delimiter, dashDelimiter, quoted, tabs, end };
 }
 function bashHeredoc(input, start, delimiter) {
   const bodyStart = start;
   let lineStart = start;
   let line = "";
+  let backslashes = 0;
   for (let index = start;index <= input.length; index++) {
     if (index < input.length && input[index] !== `
 `)
       continue;
-    const text = input.slice(start, index);
-    line += delimiter.tabs ? text.replace(/^\t+/, "") : text;
-    if (!delimiter.quoted && /(?<!\\)(?:\\\\)*\\$/.test(line) && index < input.length) {
-      line = line.slice(0, -1);
+    const text = delimiter.tabs && start === lineStart ? input.slice(start, index).replace(/^\t+/, "") : input.slice(start, index);
+    let run = 0;
+    while (text[text.length - 1 - run] === "\\")
+      run++;
+    backslashes = run === text.length ? backslashes + run : run;
+    const continued = !delimiter.quoted && backslashes % 2 === 1 && index < input.length;
+    const maxLength = Math.max(delimiter.delimiter.length, delimiter.dashDelimiter?.length ?? 0);
+    if (line.length <= maxLength)
+      line += continued ? text.slice(0, -1) : text;
+    if (continued) {
+      backslashes--;
       start = index + 1;
       continue;
     }
-    if (line === delimiter.delimiter)
+    if (delimiter.dashDelimiter !== undefined && line === delimiter.dashDelimiter)
+      return;
+    if (line === delimiter.delimiter) {
+      if (start > lineStart && input.slice(index + 1).includes(delimiter.delimiter))
+        return;
       return { source: input.slice(bodyStart, lineStart), end: index };
+    }
     line = "";
+    backslashes = 0;
     start = index + 1;
     lineStart = start;
   }