@opencode/core 2.0.23 → 2.0.24

package/dist/shell/scan.js

@@ -1,6 +1,6 @@
 import {
   __export
-} from "../chunks/generate-9rqn6x4v.js";
+} from "../chunks/repository-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 bashStatement(state) {
+  const structure = state.structures.at(-1);
+  if (structure)
+    structure.count++;
 }
-function scanBash(input, depth, budget) {
-  budget.remaining -= input.length;
-  if (input.length > MAX_INPUT_LENGTH || budget.remaining < 0 || depth > MAX_SUBSTITUTION_DEPTH)
+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;
-        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;
+      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 && 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 = (char === "=" || char === "(") && state.assignmentWord && state.word.length > 1 && state.word.endsWith("=") && !state.word.endsWith("==") && (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 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;
+}
+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 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 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 bashDelimited(input, start, depth) {
+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;
-      index++;
-      continue;
+    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;
     }
-    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;
-      }
-      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;
+    const next = input[index + 1] ?? "\x00";
+    if (input[index] === "\\" && ("$`\\\n".includes(next) || quoted && next === '"')) {
+      index++;
+      if (next !== `
+`)
+        source += next;
       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;
-      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 (char === "#" && boundary) {
-      const newline = input.indexOf(`
-`, index);
-      if (newline < 0)
-        return;
-      index = newline - 1;
-      continue;
+    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;
+      }
     }
-    if (input.startsWith("<<<", index)) {
-      index += 2;
-      continue;
+    if (char === "@") {
+      PARAMETER_PROMPT_RE.lastIndex = index;
+      if (PARAMETER_PROMPT_RE.test(input))
+        return { kind: "opaque", reason: "dynamic-execution" };
     }
-    if (input.startsWith("<<", index)) {
-      const delimiter = bashHeredocDelimiter(input, index);
-      if (!delimiter)
-        return;
-      heredocs.push(delimiter);
-      index = delimiter.end;
+    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 === `
-` && heredocs.length) {
-      for (const heredoc of heredocs.splice(0)) {
-        const body = bashHeredoc(input, index + 1, heredoc);
-        if (!body)
-          return;
-        index = body.end;
+    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;
       }
-      commandStart = true;
-      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;
-      continue;
     }
-    if (input.startsWith("((", index)) {
-      const nested = bashExpansion(input, index, depth + 1, "arithmetic");
-      if (!nested)
-        return;
-      index = nested.end;
-      commandStart = false;
+    if (!wordStarted && char === "#") {
+      const newline = input.indexOf(`
+`, index);
+      if (newline < 0)
+        return { kind: "opaque", reason: "invalid-structure" };
+      index = newline;
       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;
+    if (char === " " || char === "\t" || char === `
+`) {
+      if (!patternParenDepth)
+        wordStarted = 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;
-  }
-}
-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++) {
-    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 === ";")
+      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;
+      }
+      flushWord();
+      words.push({ word: char, literal: "", output: "" });
+      wordStarted = false;
       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;
+    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 (char === '"' && kind !== "heredoc") {
-      const nested = bashExpansion(input, index, depth + 1, "double");
-      if (!nested)
-        return;
-      substitutions.push(...nested.substitutions);
-      index = nested.end;
+    wordStarted = true;
+    hasWord = true;
+    if (unit === undefined)
+      bashAppend(text, char);
+  }
+  return { kind: "opaque", reason: "invalid-structure" };
+}
+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 (char === "\\" && input[index + 1] === `
+`) {
+      index++;
       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 (text && (char === ")" || char === " " || char === "\t" || char === `
+`)) {
+      bashEvaluatesExpansion(text, "deferred", context);
+      text.literal = "";
+      text.output = "";
     }
-    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,69 +1366,92 @@ 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;
   }
 }
 function scanPowerShell(input) {
-  return scanPowerShellNested(input, 0, { remaining: MAX_INPUT_LENGTH * MAX_SUBSTITUTION_DEPTH });
-}
-function scanPowerShellNested(input, depth, budget, hash = false) {
-  budget.remaining -= input.length;
-  if (input.length > MAX_INPUT_LENGTH || depth >= MAX_SUBSTITUTION_DEPTH || budget.remaining < 0)
+  if (input.length > MAX_INPUT_LENGTH)
     return { kind: "opaque", reason: "invalid-structure" };
   if (/[\0\u0085\u2013-\u2015\u2018-\u201e\ufeff]/.test(input))
     return { kind: "opaque", reason: "invalid-structure" };
+  const result = scanPowerShellList(input, 0, 0, { remaining: MAX_INPUT_LENGTH * MAX_SUBSTITUTION_DEPTH });
+  if (result.kind === "opaque")
+    return result;
+  return { kind: "scanned", commands: result.commands };
+}
+function scanPowerShellList(input, start, depth, budget, close, hash = false, skipped) {
+  if (depth >= MAX_SUBSTITUTION_DEPTH || budget.remaining < 0)
+    return { kind: "opaque", reason: "invalid-structure" };
   const commands = [];
   const nestedCommands = [];
   const words = [];
   const rawWords = [];
   const wordEnds = [];
-  let segment = 0;
+  const initialExpression = hash === true || hash === "clause";
+  const initialClause = hash === "clause" || hash === "switch" ? "member" : undefined;
+  let segment = start;
   let word = "";
   let started = false;
-  let wordStart = 0;
+  let wordStart = start;
   let quote;
   let standalone = false;
-  let expression = hash;
-  let compound = false;
+  let expression = initialExpression;
+  let clause = initialClause;
+  let after;
+  let indexable = false;
   let stopParsing = false;
-  let commandEnd = 0;
+  let commandEnd = start;
   let statementHead = true;
   let invalid = false;
   let redirectTarget = false;
-  let comment = false;
   let dangling = false;
   let invocation = false;
   const finishWord = (end) => {
     if (!started)
       return;
-    if (word === "--%" && words.length > 0 && !expression && !/['"]/.test(input[wordStart]))
+    if (word === "--%" && words.length > 0 && !expression && !clause && !redirectTarget && !/['"]/.test(input[wordStart]) && !rawWords.at(-1)?.endsWith(",") && !POWERSHELL_PARAMETER_COLON_RE.test(rawWords.at(-1) ?? ""))
       stopParsing = true;
     if (!redirectTarget) {
       if (!words.length && !invocation && !expression)
@@ -905,17 +1468,15 @@ function scanPowerShellNested(input, depth, budget, hash = false) {
   };
   const finishCommand = (end, required = false) => {
     finishWord(end);
-    const start = segment + input.slice(segment, commandEnd).search(/\S|$/);
-    const resource = input.slice(start, commandEnd).trimEnd();
-    if (words.length && !expression)
+    if (words.length && !expression && !clause)
       commands.push({
-        resource,
+        resource: input.slice(segment, commandEnd).trimEnd(),
         words: [...words],
         rawWords: [...rawWords],
-        wordEnds: wordEnds.map((end) => end - start),
+        wordEnds: wordEnds.map((value) => value - segment),
         ...statementHead && !invocation ? { statementHead: true } : {}
       });
-    else if (!expression && invocation || required && !words.length && !nestedCommands.length)
+    else if (!expression && !clause && invocation || required && !words.length && !nestedCommands.length || clause !== undefined && clause !== "member")
       invalid = true;
     if (redirectTarget)
       invalid = true;
@@ -925,16 +1486,25 @@ function scanPowerShellNested(input, depth, budget, hash = false) {
     wordEnds.length = 0;
     redirectTarget = false;
     invocation = false;
-    expression = hash;
-    compound = false;
+    expression = initialExpression;
+    clause = initialClause;
+    after = undefined;
+    indexable = false;
     stopParsing = false;
   };
-  for (let index = 0;index < input.length; index++) {
+  let index = start;
+  for (;index < input.length; index++) {
+    if (--budget.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (skipped?.has(index))
+      continue;
     const char = input[index];
+    const inExpression = expression && !redirectTarget;
+    const atBoundary = !started || !inExpression && word.endsWith(",");
     if (!started)
       wordStart = index;
     if (stopParsing) {
-      const stop = powerShellStopParsing(input, index);
+      const stop = powerShellStopParsing(input, index, skipped);
       const text = input.slice(index, stop).trim();
       if (text) {
         wordStart = index + input.slice(index, stop).search(/\S/);
@@ -946,43 +1516,42 @@ function scanPowerShellNested(input, depth, budget, hash = false) {
       index = stop - 1;
       continue;
     }
-    if (quote === "single") {
-      started = true;
-      if (char === "'" && input[index + 1] === "'") {
-        word += "'";
-        index++;
-      } else if (char === "'") {
-        quote = undefined;
-        if (standalone)
-          finishWord(index + 1);
-      } else
-        word += char;
-      continue;
-    }
-    if (quote === "double") {
-      if (char === '"' && input[index + 1] === '"') {
-        word += '"';
-        index++;
-      } else if (char === '"') {
+    if (quote) {
+      let nextQuote = index + 1;
+      while (skipped?.has(nextQuote))
+        nextQuote++;
+      if (char === quote && input[nextQuote] === quote) {
+        word += quote;
+        index = nextQuote;
+      } else if (char === quote) {
         quote = undefined;
-        if (standalone)
+        if (standalone) {
           finishWord(index + 1);
-      } else if (char === "`") {
-        const escape = powerShellEscape(input, index);
+          indexable = "closed";
+        }
+      } else if (quote === '"' && char === "`") {
+        const escape = powerShellEscape(input, index, false, skipped);
         if (!escape)
           return { kind: "opaque", reason: "unterminated-escape" };
         word += escape.value;
         index = escape.end;
-      } else if (char === "$" && input[index + 1] === "(") {
-        const block = powerShellBlock(input, index + 1, depth);
-        if (!block)
+      } else if (quote === '"' && char === "$" && input[index + 1] === "{") {
+        const end = powerShellBracedVariable(input, index, skipped);
+        if (end === undefined)
+          return { kind: "opaque", reason: "invalid-structure" };
+        word += input.slice(index, end + 1);
+        index = end;
+      } else if (quote === '"' && char === "$" && input[index + 1] === "(") {
+        const sub = powerShellSubExpression(input, index + 2, false, budget, skipped);
+        if (!sub)
           return { kind: "opaque", reason: "invalid-structure" };
-        const result = scanPowerShellNested(block.source, depth + 1, budget);
+        const result = scanPowerShellList(input, index + 2, depth + 1, budget, ")", false, sub.skipped);
         if (result.kind === "opaque")
           return result;
         nestedCommands.push(...result.commands);
-        word += input.slice(index, block.end + 1);
-        index = block.end;
+        const end = sub.rawEnd !== undefined && sub.rawEnd > result.end ? sub.rawEnd : result.end;
+        word += input.slice(index, end + 1);
+        index = end;
       } else
         word += char;
       continue;
@@ -990,176 +1559,203 @@ function scanPowerShellNested(input, depth, budget, hash = false) {
     if (char === "'" || char === '"') {
       if (!started && words.length === 0 && !invocation)
         expression = true;
-      quote = char === "'" ? "single" : "double";
-      standalone = !started;
+      quote = char;
+      standalone = atBoundary || expression && !redirectTarget || indexable === "member" && /[.:]$/.test(word);
+      if (!standalone)
+        indexable = false;
       started = true;
       continue;
     }
     if (char === "`") {
-      const escape = powerShellEscape(input, index);
+      const escape = powerShellEscape(input, index, atBoundary || inExpression, skipped);
       if (!escape)
         return { kind: "opaque", reason: "unterminated-escape" };
-      if (started || /\S/.test(escape.value)) {
+      const rawSpace = /\s/.test(input[index + 1] ?? "");
+      if ((inExpression || atBoundary) && started && rawSpace)
+        finishWord(index);
+      else if (!atBoundary || !rawSpace) {
         started = true;
+        indexable = false;
         word += escape.value;
       }
       index = escape.end;
       continue;
     }
-    if (!started && words.length > 0 && !expression && /^--%(?=$|[\s;|&(){}])/.test(input.slice(index))) {
+    if (!started && words.length > 0 && !expression && !clause && !redirectTarget && testAt(POWERSHELL_STOP_PARSING_RE, input, index)) {
       word = "--%";
       started = true;
       finishWord(index + 3);
-      stopParsing = true;
       index += 2;
       continue;
     }
-    if (char === "<" && input[index + 1] === "#" && !started) {
-      const end = powerShellComment(input, index);
-      if (end === undefined)
+    if (char === "<" && input[index + 1] === "#" && (atBoundary || inExpression || indexable === "member")) {
+      const memberOperator = indexable === "member" && /[.:]$/.test(started ? word : words.at(-1) ?? "");
+      if (started)
+        finishWord(index);
+      const end = input.indexOf("#>", index + 2);
+      if (end < 0)
         return { kind: "opaque", reason: "invalid-structure" };
-      if (!words.length && !invocation)
-        segment = end + 1;
-      index = end;
+      if (!memberOperator)
+        indexable = false;
+      index = end + 1;
       continue;
     }
-    if (char === "#" && (!started || expression)) {
-      if (words.length || started || invocation)
+    if (char === "#" && (atBoundary || indexable === "member" || inExpression && !(close === "]" && /^[\p{L}\p{Nl}_][\p{L}\p{Nl}\d_.#+`\\]*$/u.test(word)))) {
+      const prev = started ? word : words.at(-1) ?? "";
+      const memberOperator = indexable === "member" && /[.:]$/.test(prev);
+      if (clause && clause !== "member" || prev.endsWith(",") || memberOperator)
+        finishWord(index);
+      else if (words.length || started || invocation)
         finishCommand(index);
       statementHead = !dangling;
-      comment = true;
       const endings = [input.indexOf(`
 `, index), input.indexOf("\r", index)].filter((ending) => ending >= 0);
       const newline = endings.length > 0 ? Math.min(...endings) : -1;
-      if (newline === -1)
+      if (newline === -1) {
+        index = input.length;
         break;
-      comment = false;
+      }
       index = input[newline] === "\r" && input[newline + 1] === `
 ` ? newline + 1 : newline;
-      segment = index + 1;
       continue;
     }
-    const redirect = !started && (char === ">" || char === "*" || /\d/.test(char)) ? powerShellRedirect(input, index) : undefined;
+    if (inExpression && started && (char === ">" || char === "*" && input[index + 1] === ">"))
+      finishWord(index);
+    const redirect = !started && (char === ">" || char === "*" || /\d/.test(char) && (words.length > 0 || testAt(POWERSHELL_MERGE_REDIRECT_RE, input, index))) ? powerShellRedirect(input, index) : undefined;
     if (redirect === false)
       return { kind: "opaque", reason: "invalid-redirect" };
     if (redirect) {
-      if (redirectTarget)
-        return { kind: "opaque", reason: "invalid-redirect" };
-      if (words.length === 0)
+      if (redirectTarget || words.length === 0 || clause && clause !== "member")
         return { kind: "opaque", reason: "invalid-redirect" };
       redirectTarget = !redirect.includes("&");
+      indexable = false;
       index += redirect.length - 1;
       commandEnd = index + 1;
       continue;
     }
-    if (!started && !words.length && !invocation && !expression && /[A-Za-z]/.test(char)) {
-      const keyword = /^[A-Za-z]+(?=$|[\s({])/.exec(input.slice(index))?.[0]?.toLowerCase();
-      if (keyword && /^(?:if|elseif|else|for|while|do|until|switch|function|filter|try|catch|finally|begin|process|end|clean|param|trap|class|enum|data|dynamicparam|using)$/.test(keyword)) {
-        expression = true;
-        compound = true;
-        index += keyword.length - 1;
+    if (!started && !words.length && !invocation && !expression && !clause && char === ":") {
+      const label = matchAt(POWERSHELL_LABEL_RE, input, index);
+      if (label) {
+        index += label[0].length - 1;
         continue;
       }
-      if (keyword === "foreach" && /^foreach\s*\(/i.test(input.slice(index))) {
-        expression = true;
-        compound = true;
+    }
+    if (!started && !invocation && !clause && (!words.length ? !expression : words.every((item) => item.startsWith("["))) && /[A-Za-z]/.test(char)) {
+      const keyword = matchAt(POWERSHELL_KEYWORD_RE, input, index)?.[0]?.toLowerCase();
+      if (keyword && (words.length > 0 ? keyword === "param" && testAt(POWERSHELL_PARAM_RE, input, index) || keyword === "class" || keyword === "enum" : keyword === "param" && testAt(POWERSHELL_PARAM_RE, input, index) || keyword === "foreach" && testAt(POWERSHELL_FOREACH_RE, input, index) || keyword === "until" && after === "do" || (keyword === "else" || keyword === "elseif") && after === "if" || (keyword === "catch" || keyword === "finally") && after === "try" || /^(?:if|for|while|do|switch|function|filter|workflow|parallel|sequence|configuration|try|begin|process|end|clean|trap|class|enum|data|dynamicparam|using|break|continue)$/.test(keyword))) {
+        expression = /^(?:class|enum|break|continue)$/.test(keyword);
+        clause = keyword === "using" || keyword === "break" || keyword === "continue" ? "member" : keyword === "param" || keyword === "until" || keyword === "while" && after === "do" ? "paren" : keyword === "do" ? "do" : keyword === "if" || keyword === "elseif" ? "if" : keyword === "try" || keyword === "catch" ? "try" : keyword === "switch" ? "switch" : keyword === "class" || keyword === "enum" ? "clause" : "block";
+        after = undefined;
         index += keyword.length - 1;
         continue;
       }
-      if (keyword && /^(?:return|throw|exit|break|continue)$/.test(keyword)) {
+      if (!words.length && keyword && /^(?:return|throw|exit)$/.test(keyword)) {
+        after = undefined;
         index += keyword.length - 1;
-        segment = index + 1;
         continue;
       }
     }
-    if (expression && !compound && (char === "=" || /[-+*/%]/.test(char) && input[index + 1] === "=")) {
-      finishWord(index);
+    const assign = inExpression && !clause && (char === "=" || /[-+*/%]/.test(char) && input[index + 1] === "=");
+    if (assign || inExpression && close === ")" && !started && testAt(POWERSHELL_IN_RE, input, index)) {
+      if (assign)
+        finishWord(index);
       words.length = 0;
       rawWords.length = 0;
       wordEnds.length = 0;
       expression = false;
-      if (char !== "=")
+      indexable = false;
+      if (!assign || char !== "=")
         index++;
-      segment = index + 1;
-      continue;
-    }
-    if (expression && !started && /^in\b/i.test(input.slice(index))) {
-      words.length = 0;
-      rawWords.length = 0;
-      wordEnds.length = 0;
-      expression = false;
-      index++;
-      segment = index + 1;
       continue;
     }
-    if (char === "@" && /['"]/.test(input[index + 1] ?? "")) {
-      const literal = powerShellHereString(input, index);
-      if (!literal)
-        return { kind: "opaque", reason: "unterminated-quote" };
+    if (atBoundary && char === "@" && !testAt(POWERSHELL_AT_OPENER_RE, input, index + 1))
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (atBoundary && char === "@" && (input[index + 1] === "'" || input[index + 1] === '"')) {
+      if (started)
+        finishWord(index);
+      wordStart = index;
+      const literal = powerShellHereString(input, index, depth, budget, skipped);
+      if (literal.kind === "opaque")
+        return literal;
       if (!words.length && !invocation)
         expression = true;
-      if (input[index + 1] === '"') {
-        const result = powerShellExpansions(literal.source, depth + 1, budget);
-        if (result.kind === "opaque")
-          return result;
-        nestedCommands.push(...result.commands);
-      }
+      nestedCommands.push(...literal.commands);
       word = literal.source;
       started = true;
       index = literal.end;
       finishWord(index + 1);
+      indexable = "closed";
       continue;
     }
     if (char === "$" && input[index + 1] === "{") {
-      const end = input.indexOf("}", index + 2);
-      if (end < 0)
+      const end = powerShellBracedVariable(input, index, skipped);
+      if (end === undefined)
         return { kind: "opaque", reason: "invalid-structure" };
-      if (!started && !words.length && !invocation)
+      if (!started && !words.length && !invocation && hash !== "switch")
         expression = true;
+      indexable = atBoundary || indexable === "member" && /[.:]$/.test(word) ? "closed" : false;
       word += input.slice(index, end + 1);
       started = true;
       index = end;
+      if (expression && !redirectTarget && input[index + 1] !== "[")
+        finishWord(index + 1);
       continue;
     }
-    const opener = (char === "$" || char === "@") && input[index + 1] === "(" ? index + 1 : char === "@" && input[index + 1] === "{" ? index + 1 : char === "(" || char === "{" || char === "[" && (expression || !started) ? index : undefined;
+    const opener = (char === "$" || atBoundary && char === "@") && input[index + 1] === "(" ? index + 1 : atBoundary && char === "@" && input[index + 1] === "{" ? index + 1 : char === "(" || char === "{" || char === "[" && (inExpression || Boolean(indexable) || !started && !invocation && (!words.length || clause === "block" || clause === "try")) ? index : undefined;
     if (opener !== undefined) {
-      if (started && (char === "{" || char === "(")) {
+      const openChar = input[opener];
+      const standaloneBlock = atBoundary || inExpression || char === "(" || openChar === "{";
+      const blockClose = openChar === "(" ? ")" : openChar === "[" ? "]" : "}";
+      const blockHash = openChar === "[" ? true : char === "@" && openChar === "{" ? true : clause === "switch" && openChar === "{" ? "switch" : clause === "clause" && openChar === "{" ? "clause" : close === "]" && char === "(" && started ? "clause" : false;
+      if (started && (char === "{" || char === "(" || char === "@" && atBoundary)) {
         finishWord(index);
+        if (stopParsing) {
+          index--;
+          continue;
+        }
         wordStart = index;
       }
       if (!started && !words.length && !invocation)
         expression = true;
-      const block = powerShellBlock(input, opener, depth);
-      if (!block)
-        return { kind: "opaque", reason: "invalid-structure" };
-      const result = scanPowerShellNested(block.source, depth + 1, budget, input[opener] === "[" || char === "@" && input[opener] === "{");
+      const result = scanPowerShellList(input, opener + 1, depth + 1, budget, blockClose, blockHash, skipped);
       if (result.kind === "opaque")
         return result;
       nestedCommands.push(...result.commands);
       started = true;
-      word += input.slice(index, block.end + 1);
-      index = block.end;
-      if (input[opener] === "{" || char === "(")
+      word += input.slice(index, result.end + 1);
+      index = result.end;
+      if (openChar === "[") {
+        indexable = "closed";
+        if (input[index + 1] !== "[")
+          finishWord(index + 1);
+      } else if (standaloneBlock) {
         finishWord(index + 1);
-      if (compound && input[opener] === "{") {
+        indexable = "closed";
+      }
+      if (clause === "paren" && char === "(" || clause && clause !== "paren" && char === "{") {
+        const completed = clause === "do" || clause === "if" || clause === "try" ? clause : undefined;
+        clause = "member";
         finishCommand(index + 1);
-        segment = index + 1;
+        after = completed;
       }
       continue;
     }
-    if (char === "}" || char === ")")
+    if (char === close)
+      break;
+    if (char === "}" || char === ")" || char === "]" && inExpression)
       return { kind: "opaque", reason: "invalid-structure" };
-    if (!started && words.length === 0 && (char === "&" && input[index + 1] !== "&" || char === "." && (/\s/.test(input[index + 1] ?? "") || !input[index + 1]))) {
+    if (!started && words.length === 0 && (char === "&" && input[index + 1] !== "&" || char === "." && (!input[index + 1] || /[\s"'$(),;{|}&]/.test(input[index + 1])))) {
       if (invocation)
         return { kind: "opaque", reason: "invalid-structure" };
+      segment = index;
       invocation = true;
+      after = undefined;
       continue;
     }
-    if (!started && !words.length && !invocation && powerShellExpression(input.slice(index)))
-      expression = true;
     if (/\s/.test(char) && char !== `
 ` && char !== "\r") {
       finishWord(index);
+      indexable = false;
       continue;
     }
     const next = input[index + 1];
@@ -1167,12 +1763,25 @@ function scanPowerShellNested(input, depth, budget, hash = false) {
 ` ? char + next : char === "&" && next === "&" || char === "|" && next === "|" ? char + next : char === ";" || char === "|" || char === "&" || char === `
 ` || char === "\r" ? char : undefined;
     if (separator) {
-      if ((separator === `
+      if (close === "]" && (separator === ";" || separator === "|" || separator === "||" || separator === "&&" || separator === "&"))
+        return { kind: "opaque", reason: "invalid-structure" };
+      if (separator === `
 ` || separator === "\r" || separator === `\r
-`) && !started && !words.length && !invocation) {
-        index += separator.length - 1;
-        segment = index + 1;
-        continue;
+`) {
+        const prev = started ? word : words.at(-1) ?? "";
+        const memberOperator = indexable === "member" && /[.:]$/.test(prev);
+        if (clause && clause !== "member" || prev.endsWith(",") || memberOperator) {
+          finishWord(index);
+          index += separator.length - 1;
+          if (!memberOperator)
+            indexable = false;
+          continue;
+        }
+        if (!started && !words.length && !invocation) {
+          index += separator.length - 1;
+          indexable = false;
+          continue;
+        }
       }
       finishCommand(index, dangling || ![";", `
 `, "\r", `\r
@@ -1182,190 +1791,47 @@ function scanPowerShellNested(input, depth, budget, hash = false) {
 `].includes(separator);
       statementHead = !dangling;
       index += separator.length - 1;
-      segment = index + 1;
       continue;
     }
+    if (!started && !words.length && !invocation && hash !== "switch" && testAt(POWERSHELL_EXPRESSION_RE, input, index))
+      expression = true;
+    if ((atBoundary || indexable === "member" && /[.:]$/.test(word)) && char === "$")
+      indexable = testAt(POWERSHELL_INDEXABLE_VAR_RE, input, index + 1) ? "variable" : false;
+    else if (indexable === "closed")
+      indexable = char === "." && input[index + 1] !== "." && !/\s/.test(input[index + 1] ?? "") || !started && char === ":" && input[index + 1] === ":" && !/\s/.test(input[index + 2] ?? "") || !started && char === "?" && input[index + 1] === "." && input[index + 2] !== "." && !/\s/.test(input[index + 2] ?? "") ? "member" : !started && char === "?" && input[index + 1] === "[" ? "closed" : false;
+    else if (indexable === "variable")
+      indexable = char === "." && input[index + 1] !== "." && !/\s/.test(input[index + 1] ?? "") || char === ":" && input[index + 1] === ":" && !/\s/.test(input[index + 2] ?? "") ? "member" : char === "." && input[index + 1] === "." || !/[\p{L}\p{Nl}\d_:?]/u.test(char) ? false : "variable";
+    else if (indexable === "member")
+      indexable = char === "." && input[index + 1] === "." ? false : char === "." && !/\s/.test(input[index + 1] ?? "") || char === ":" && (input[index + 1] === ":" || input[index - 1] === ":") || char === "?" && input[index + 1] === "." && input[index + 2] !== "." || /[\p{L}\p{Nl}\d_]/u.test(char) ? "member" : false;
+    after = undefined;
     started = true;
     dangling = false;
     word += char;
   }
+  if (close !== undefined && input[index] !== close)
+    return { kind: "opaque", reason: "invalid-structure" };
   if (quote)
     return { kind: "opaque", reason: "unterminated-quote" };
-  if (!comment)
-    finishCommand(input.length);
+  finishCommand(index);
   if (redirectTarget || invalid || dangling)
     return { kind: "opaque", reason: "invalid-structure" };
   if (commands.some((command) => !command.words[0]))
     return { kind: "opaque", reason: "dynamic-command-name" };
-  return { kind: "scanned", commands };
-}
-function powerShellBlock(input, start, depth) {
-  if (depth >= MAX_SUBSTITUTION_DEPTH)
-    return;
-  let quote;
-  let standalone = false;
-  let started = false;
-  let head = true;
-  let expression = false;
-  let token = "";
-  const close = input[start] === "(" ? ")" : input[start] === "[" ? "]" : "}";
-  for (let index = start + 1;index < input.length; index++) {
-    const char = input[index];
-    if (quote === "single") {
-      if (char === "'" && input[index + 1] === "'") {
-        token += "'";
-        index++;
-      } else if (char === "'") {
-        quote = undefined;
-        started = !standalone;
-        if (standalone)
-          token = "";
-      } else
-        token += char;
-      continue;
-    }
-    if (quote === "double") {
-      if (char === "`") {
-        const escape = powerShellEscape(input, index);
-        if (!escape)
-          return;
-        token += escape.value;
-        index = escape.end;
-      } else if (char === '"' && input[index + 1] === '"') {
-        token += '"';
-        index++;
-      } else if (char === '"') {
-        quote = undefined;
-        started = !standalone;
-        if (standalone)
-          token = "";
-      } else if (char === "$" && input[index + 1] === "(") {
-        const nested = powerShellBlock(input, index + 1, depth + 1);
-        if (!nested)
-          return;
-        index = nested.end;
-      } else
-        token += char;
-      continue;
-    }
-    if (char === "`") {
-      const escape = powerShellEscape(input, index);
-      if (!escape)
-        return;
-      if (started || /\S/.test(escape.value)) {
-        started = true;
-        token += escape.value;
-      }
-      index = escape.end;
-      continue;
-    }
-    if (char === "<" && input[index + 1] === "#" && !started) {
-      const end = powerShellComment(input, index);
-      if (end === undefined)
-        return;
-      index = end;
-      continue;
-    }
-    if (char === "#" && (!started || expression)) {
-      const endings = [input.indexOf(`
-`, index), input.indexOf("\r", index)].filter((ending) => ending >= 0);
-      const newline = endings.length > 0 ? Math.min(...endings) : -1;
-      if (newline < 0)
-        return;
-      index = newline;
-      started = false;
-      head = true;
-      expression = false;
-      token = "";
-      continue;
-    }
-    if (char === "@" && /['"]/.test(input[index + 1] ?? "")) {
-      const literal = powerShellHereString(input, index);
-      if (!literal)
-        return;
-      index = literal.end;
-      started = false;
-      head = false;
-      continue;
-    }
-    if (head && !started && (char === "&" && input[index + 1] !== "&" || char === "." && /\s/.test(input[index + 1] ?? ""))) {
-      head = false;
-      continue;
-    }
-    if (expression && (char === "=" || !started && /^in\b/i.test(input.slice(index)))) {
-      if (char !== "=")
-        index++;
-      expression = false;
-      head = true;
-      started = false;
-      token = "";
-      continue;
-    }
-    if (char === "'" || char === '"') {
-      quote = char === "'" ? "single" : "double";
-      standalone = !started;
-      if (head && !started)
-        expression = true;
-      started = true;
-      continue;
-    }
-    const redirect = !started && (char === ">" || char === "*" || /\d/.test(char)) ? powerShellRedirect(input, index) : undefined;
-    if (redirect === false)
-      return;
-    if (redirect) {
-      index += redirect.length - 1;
-      token = "";
-      continue;
-    }
-    if (char === "$" && input[index + 1] === "{") {
-      const end = input.indexOf("}", index + 2);
-      if (end < 0)
-        return;
-      if (head && !started)
-        expression = true;
-      index = end;
-      started = true;
-      continue;
-    }
-    if (!started && !head && !expression && /^--%(?=$|[\s;|&(){}])/.test(input.slice(index))) {
-      index = powerShellStopParsing(input, index + 3) - 1;
-      continue;
-    }
-    if (char === close)
-      return { source: input.slice(start + 1, index), end: index };
-    if (char === "(" || char === "{" || char === "[" && (!started || expression)) {
-      if (head && !started)
-        expression = true;
-      const nested = powerShellBlock(input, index, depth + 1);
-      if (!nested)
-        return;
-      index = nested.end;
-      started = false;
-      head = false;
-      token = "";
-      continue;
-    }
-    if (/[\s;&|]/.test(char)) {
-      if (token === "--%" && !expression) {
-        index = powerShellStopParsing(input, index) - 1;
-        token = "";
-        continue;
-      }
-      if (/[;&|\r\n]/.test(char)) {
-        head = true;
-        expression = false;
-      } else if (started)
-        head = false;
-      started = false;
-      token = "";
-      continue;
-    }
-    if (head && !started && powerShellExpression(input.slice(index)))
-      expression = true;
-    started = true;
-    token += char;
-  }
+  return { kind: "scanned", commands, end: index };
 }
+var POWERSHELL_STOP_PARSING_RE = /--%(?=$|[\s;|&(){}])/y;
+var POWERSHELL_PARAMETER_COLON_RE = /^-[\p{L}\p{Nl}_?][\p{L}\p{Nl}\d_?-]*:$/u;
+var POWERSHELL_MERGE_REDIRECT_RE = /\d>&/y;
+var POWERSHELL_LABEL_RE = /:[A-Za-z_]\w*(?=\s*(?:while|for|foreach|do|switch)(?=$|[\s&(),;{|}]))/iy;
+var POWERSHELL_KEYWORD_RE = /[A-Za-z]+(?=$|[\s&(),;{|}])/y;
+var POWERSHELL_FOREACH_RE = /foreach\s*\(/isy;
+var POWERSHELL_PARAM_RE = /param\s*\(/isy;
+var POWERSHELL_IN_RE = /in(?=$|[\s&(),;{|}])/iy;
+var POWERSHELL_AT_OPENER_RE = /[({'"\p{L}\p{Nl}\d_?]/uy;
+var POWERSHELL_INDEXABLE_VAR_RE = /(?::[\p{L}\p{Nl}\d_?]+|[\p{L}\p{Nl}\d_][\p{L}\p{Nl}\d_?]*)/uy;
+var POWERSHELL_HERE_HEADER_RE = /@['"][^\S\r\n]*(?:\r\n|\r|\n)/y;
+var POWERSHELL_UNICODE_ESCAPE_RE = /u\{([0-9a-f]{1,6})\}/iy;
+var POWERSHELL_EXPRESSION_RE = /(?:!*(?:\+\+|--|[+-])?\$(?:\{|(?:\?|\$|\^)(?=$|[\s;|&(){},#>])|:[\p{L}\p{Nl}\d_?]+|[\p{L}\p{Nl}\d_][\p{L}\p{Nl}\d_?]*(?::[\p{L}\p{Nl}\d_?]+)?)|!(?![\p{L}\p{Nl}_.\d])|\+(?![=\p{L}\p{Nl}_.\d])|--(?!=)|-(?![=\p{L}\p{Nl}\d_?.])|,(?!\s*$)|!*[+-]?(?:0[xX][\da-fA-F]+|0[bB][01]+|(?:\d+(?:\.(?!\.)\d*|(?!\.(?!\.)))|\.\d+)(?:[eE][+-]?\d+)?)(?:[dDlLnN]|[uU][sSyYlL]?|[sSyY])?(?:[kKmMgGtTpP][bB])?(?=$|[\s!#%&()*+,\-/.;<=>\]|{}])|-(?:not|bnot|join|[ic]?split)(?![\p{L}\p{Nl}]))/iuy;
 var POWERSHELL_ESCAPES = {
   "0": "\x00",
   a: "\x07",
@@ -1378,80 +1844,145 @@ var POWERSHELL_ESCAPES = {
   t: "\t",
   v: "\v"
 };
-function powerShellEscape(input, start) {
-  const char = input[start + 1];
+function matchAt(regex, input, index) {
+  regex.lastIndex = index;
+  return regex.exec(input);
+}
+function testAt(regex, input, index) {
+  regex.lastIndex = index;
+  return regex.test(input);
+}
+function powerShellEscape(input, start, lineContinuation = false, skipped) {
+  let next = start + 1;
+  while (skipped?.has(next))
+    next++;
+  const char = input[next];
   if (char === undefined)
     return;
   if (char === "\r" || char === `
 `)
     return {
-      value: char === "\r" && input[start + 2] === `
+      value: lineContinuation && char === "\r" && input[next + 1] === `
 ` ? `\r
 ` : char,
-      end: start + (char === "\r" && input[start + 2] === `
-` ? 2 : 1)
+      end: next + (lineContinuation && char === "\r" && input[next + 1] === `
+` ? 1 : 0)
     };
-  if (char === "u" && input[start + 2] === "{") {
-    const code = /^u\{([0-9a-f]{1,6})\}/i.exec(input.slice(start + 1));
+  if (char === "u" && input[next + 1] === "{") {
+    const code = matchAt(POWERSHELL_UNICODE_ESCAPE_RE, input, next);
     if (!code || Number.parseInt(code[1], 16) > 1114111)
       return;
-    return { value: String.fromCodePoint(Number.parseInt(code[1], 16)), end: start + code[0].length };
+    return { value: String.fromCodePoint(Number.parseInt(code[1], 16)), end: next + code[0].length - 1 };
+  }
+  return { value: POWERSHELL_ESCAPES[char] ?? char, end: next };
+}
+function powerShellBracedVariable(input, start, skipped) {
+  for (let index = start + 2;index < input.length; index++) {
+    if (skipped?.has(index))
+      continue;
+    if (input[index] === "`") {
+      const escape = powerShellEscape(input, index, false, skipped);
+      if (!escape)
+        return;
+      index = escape.end;
+      continue;
+    }
+    if (input[index] === "}")
+      return index > start + 2 ? index : undefined;
   }
-  return { value: POWERSHELL_ESCAPES[char] ?? char, end: start + 1 };
 }
-function powerShellExpression(input) {
-  return /^(?:[$!,+]|[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?(?:[dDlLnNuU]|[kKmMgGtTpP][bB])?(?![\w'"`])|0[xX][\da-fA-F]+\b|0[bB][01]+\b|\.[0-9]|-(?:not|bnot|join|split)\b)/i.test(input);
+function powerShellSubExpression(input, start, hereString, budget, skipped) {
+  const nextSkipped = new Set(skipped);
+  let depth = 1;
+  let rawEnd;
+  for (let index = start;index < input.length; index++) {
+    if (--budget.remaining < 0)
+      return;
+    if (nextSkipped.has(index))
+      continue;
+    const char = input[index];
+    if (char === "(")
+      depth++;
+    else if (char === ")") {
+      if (--depth === 0 && rawEnd === undefined)
+        rawEnd = index;
+    } else if (!hereString && (char === '"' || char === "`")) {
+      let next = index + 1;
+      while (nextSkipped.has(next))
+        next++;
+      if (input[next] === '"') {
+        nextSkipped.add(index);
+        index = next;
+      }
+    }
+  }
+  return { skipped: nextSkipped, rawEnd };
 }
-function powerShellStopParsing(input, start) {
+function powerShellStopParsing(input, start, skipped) {
   let quoted = false;
   for (let index = start;index < input.length; index++) {
+    if (skipped?.has(index))
+      continue;
     if (input[index] === '"')
       quoted = !quoted;
     if (input[index] === "\r" || input[index] === `
-` || input[index] === "|" && !quoted)
+` || (input[index] === "|" || input[index] === "&" && input[index + 1] === "&") && !quoted)
       return index;
   }
   return input.length;
 }
-function powerShellComment(input, start) {
-  const end = input.indexOf("#>", start + 2);
-  return end < 0 ? undefined : end + 1;
-}
-function powerShellHereString(input, start) {
-  const header = /^@['"][ \t]*(?:\r\n|\r|\n)/.exec(input.slice(start));
+function powerShellHereString(input, start, depth, budget, skipped) {
+  const header = matchAt(POWERSHELL_HERE_HEADER_RE, input, start);
   if (!header)
-    return;
+    return { kind: "opaque", reason: "unterminated-quote" };
+  const quote = input[start + 1];
   const body = start + header[0].length;
+  const commands = [];
+  let lineStart = true;
   for (let index = body;index < input.length; index++) {
-    if (index !== body && input[index - 1] !== "\r" && input[index - 1] !== `
-`)
-      continue;
-    if (input[index] !== input[start + 1] || input[index + 1] !== "@")
+    if (--budget.remaining < 0)
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (skipped?.has(index))
       continue;
-    const end = index > body && input[index - 1] === `
+    if (lineStart && input[index] === quote && input[index + 1] === "@") {
+      const end = index > body && input[index - 1] === `
 ` && input[index - 2] === "\r" ? index - 2 : index > body ? index - 1 : index;
-    return { source: input.slice(body, end), end: index + 1 };
-  }
-}
-function powerShellExpansions(input, depth, budget) {
-  const commands = [];
-  for (let index = 0;index < input.length; index++) {
-    if (input[index] === "`") {
-      index++;
-      continue;
+      return { kind: "scanned", commands, source: input.slice(body, end), end: index + 1 };
     }
-    if (!input.startsWith("$(", index))
-      continue;
-    const block = powerShellBlock(input, index + 1, depth);
-    if (!block)
-      return { kind: "opaque", reason: "invalid-structure" };
-    const result = scanPowerShellNested(block.source, depth + 1, budget);
-    if (result.kind === "opaque")
-      return result;
-    commands.push(...result.commands);
-    index = block.end;
+    if (quote === '"') {
+      if (input[index] === "`") {
+        const escape = powerShellEscape(input, index, false, skipped);
+        if (!escape)
+          return { kind: "opaque", reason: "unterminated-escape" };
+        index = escape.end;
+        lineStart = false;
+        continue;
+      }
+      if (input[index] === "$" && input[index + 1] === "{") {
+        const end = powerShellBracedVariable(input, index, skipped);
+        if (end === undefined)
+          return { kind: "opaque", reason: "invalid-structure" };
+        index = end;
+        lineStart = false;
+        continue;
+      }
+      if (input[index] === "$" && input[index + 1] === "(") {
+        const sub = powerShellSubExpression(input, index + 2, true, budget, skipped);
+        if (!sub)
+          return { kind: "opaque", reason: "invalid-structure" };
+        const result = scanPowerShellList(input, index + 2, depth + 1, budget, ")", false, sub.skipped);
+        if (result.kind === "opaque")
+          return result;
+        commands.push(...result.commands);
+        index = sub.rawEnd !== undefined && sub.rawEnd > result.end ? sub.rawEnd : result.end;
+        lineStart = false;
+        continue;
+      }
+    }
+    lineStart = input[index] === "\r" || input[index] === `
+`;
   }
-  return { kind: "scanned", commands };
+  return { kind: "opaque", reason: "unterminated-quote" };
 }
 function powerShellRedirect(input, index) {
   let cursor = index;