@opencode-ai/core 0.0.0-dev-18334 → 0.0.0-dev-18339

package/dist/shell/scan.js

@@ -1,92 +1,73 @@
 import {
   __export
-} from "../chunks/pty-rvfvac9x.js";
+} from "../chunks/kv-rvfvac9x.js";
 
 // src/shell/scan.ts
 var exports_scan = {};
 __export(exports_scan, {
   scanPowerShell: () => scanPowerShell,
   scan: () => scan,
-  ShellScan: () => exports_scan,
-  Nested: () => Nested
+  ShellScan: () => exports_scan
 });
-var Nested = Symbol("ShellScan.Nested");
-var BASH_COMPOUND_KEYWORDS = new Set([
-  "if",
-  "then",
-  "elif",
-  "else",
-  "fi",
-  "for",
-  "while",
-  "until",
-  "case",
-  "select",
-  "function",
-  "do",
-  "done",
-  "coproc"
-]);
-var POWERSHELL_LOCATIONS = new Set(["set-location", "cd", "chdir", "sl", "push-location", "pushd"]);
 var BASH_REDIRECTS = ["&>>", "&>", "<<<", "<<-", "<<", "<>", "<&", ">&", ">|", ">>", ">", "<"];
-var MAX_BASH_INPUT_LENGTH = 64 * 1024;
+var BASH_DECLARATIONS = new Set(["declare", "typeset", "export", "readonly", "local", "unset", "unsetenv"]);
+var MAX_INPUT_LENGTH = 64 * 1024;
 var MAX_SUBSTITUTION_DEPTH = 32;
 function scan(input) {
-  return scanBash(input, 0);
+  return scanBash(input, 0, { remaining: MAX_INPUT_LENGTH * MAX_SUBSTITUTION_DEPTH });
 }
-function scanBash(input, depth) {
-  if (input.length > MAX_BASH_INPUT_LENGTH)
+function scanBash(input, depth, budget) {
+  budget.remaining -= input.length;
+  if (input.length > MAX_INPUT_LENGTH || budget.remaining < 0 || depth > MAX_SUBSTITUTION_DEPTH)
     return { kind: "opaque", reason: "invalid-structure" };
-  const group = bashLeadingGroup(input);
-  if (group) {
-    if (depth >= MAX_SUBSTITUTION_DEPTH)
-      return { kind: "opaque", reason: "invalid-structure" };
-    const nested = scanBash(group.source, depth + 1);
-    if (nested.kind === "opaque")
-      return nested;
-    const suffix = input.slice(group.end + 1).trim();
-    if (!suffix)
-      return nested;
-    const separator = /^(?:&&|\|\||\|&|[;&|])/.exec(suffix)?.[0];
-    const remaining = separator ? suffix.slice(separator.length).trim() : suffix;
-    if (separator && !remaining)
-      return nested;
-    const prefixed = separator ? remaining : /^[<>]/.test(remaining) ? `: ${remaining}` : undefined;
-    if (!prefixed)
-      return { kind: "opaque", reason: "compound-command" };
-    const rest = scanBash(prefixed, depth + 1);
-    if (rest.kind === "opaque")
-      return rest;
-    return {
-      kind: "scanned",
-      commands: nested.commands.concat(rest.commands.filter((command) => command.words[0] !== ":"))
-    };
-  }
   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 compound = false;
   let invalidRedirect = false;
   let invalidStructure = false;
   let separated = false;
-  let comment;
-  let heredoc = false;
   let redirectTarget = false;
   let hasRedirect = false;
-  let terminalBackground = 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;
     }
     redirectTarget = false;
     word = "";
@@ -94,29 +75,185 @@ function scanBash(input, depth) {
     assignmentWord = false;
     assignmentHeadUnsafe = false;
   };
-  const finishCommand = (end, boundary = false) => {
+  const finishCommand = (boundary = false) => {
     finishWord();
-    const resource = input.slice(segment, end).trim();
+    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 && /[*?[]/.test(words[name]))
-      compound = true;
-    if (resource && name >= 0)
-      commands.push({
-        resource,
-        words: words.slice(name)
-      });
-    else if (!(assignmentWords.length > 0 && assignmentWords.every(Boolean)) && (hasRedirect || boundary || separated))
+    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;
+        }
+      }
+    } 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;
   };
   for (let index = 0;index < input.length; index++) {
     const char = input[index];
+    if (!wordStarted)
+      wordStart = index;
+    if (!quote && !wordStarted) {
+      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 (!words.length && !hasRedirect && !compoundEnd) {
+        const definition = /^(?:function[ \t]+[A-Za-z_][A-Za-z0-9_]*(?:[ \t]*\([ \t]*\))?|[A-Za-z_][A-Za-z0-9_]*[ \t]*\([ \t]*\))[ \t\n]*(?=[{(])/.exec(input.slice(index));
+        if (definition && !header()) {
+          index += definition[0].length - 1;
+          segment = index + 1;
+          continue;
+        }
+        if (!header() && (token === "if" || token === "while" || token === "until" || token === "for" || token === "select" || token === "case")) {
+          if (depth + structures.length >= MAX_SUBSTITUTION_DEPTH)
+            return { kind: "opaque", reason: "compound-command" };
+          structures.push({
+            kind: token === "select" ? "for" : token,
+            phase: ["for", "select", "case"].includes(token) ? "header" : "condition",
+            count: 0
+          });
+          index += token.length - 1;
+          segment = index + 1;
+          inList = false;
+          continue;
+        }
+        if (token && ["then", "elif", "else", "fi", "do", "done", "esac"].includes(token) && (!header() || token === "do" && structure?.phase === "do" || token === "esac" && structure?.phase === "pattern")) {
+          if (!structure || dangling)
+            return { kind: "opaque", reason: "compound-command" };
+          if (token === "then") {
+            if (structure.kind !== "if" || structure.phase !== "condition" || !structure.count)
+              return { kind: "opaque", reason: "compound-command" };
+            structure.phase = "body";
+          } else if (token === "elif" || token === "else") {
+            if (structure.kind !== "if" || structure.phase !== "body" || !structure.count || structure.sawElse)
+              return { kind: "opaque", reason: "compound-command" };
+            structure.phase = token === "elif" ? "condition" : "body";
+            structure.sawElse = token === "else";
+          } else if (token === "do") {
+            if (!["for", "while", "until"].includes(structure.kind) || !["condition", "do"].includes(structure.phase) || structure.kind !== "for" && !structure.count)
+              return { kind: "opaque", reason: "compound-command" };
+            structure.phase = "body";
+          } else {
+            if (token === "fi" && (structure.kind !== "if" || structure.phase !== "body" || !structure.count) || token === "done" && (!["for", "while", "until"].includes(structure.kind) || structure.phase !== "body" || !structure.count) || token === "esac" && (structure.kind !== "case" || structure.phase === "header"))
+              return { kind: "opaque", reason: "compound-command" };
+            structures.pop();
+            statement();
+            compoundEnd = true;
+            dangling = false;
+          }
+          structure.count = 0;
+          index += token.length - 1;
+          segment = index + 1;
+          inList = false;
+          continue;
+        }
+        if (!header() && (char === "!" && /[ \t\n]/.test(input[index + 1] ?? "") || token === "coproc" && /^coproc[ \t]+(?:[A-Za-z_][A-Za-z0-9_]*[ \t]+)?(?:[{(]|(?:if|while|until|for|case)\b)/.test(input.slice(index)) || token === "time" && /^time[ \t]+(?:-p[ \t]+)?(?:[{(]|(?:if|while|until|for|case)\b)/.test(input.slice(index)))) {
+          index += token ? token.length - 1 : 0;
+          if (token === "time")
+            index += /^[ \t]+-p\b/.exec(input.slice(index + 1))?.[0].length ?? 0;
+          if (token === "coproc")
+            index += /^[ \t]+[A-Za-z_][A-Za-z0-9_]*[ \t]+(?=[{(]|(?:if|while|until|for|case)\b)/.exec(input.slice(index + 1))?.[0].length ?? 0;
+          segment = index + 1;
+          continue;
+        }
+      }
+      if ((!words.length && !hasRedirect && !header() || structure?.kind === "for" && structure.phase === "header") && input.startsWith("((", index)) {
+        const expression = bashExpansion(input, index, depth, "arithmetic");
+        if (!expression)
+          return { kind: "opaque", reason: "invalid-structure" };
+        const failure = addSubstitutions(expression);
+        if (failure)
+          return failure;
+        commands.push(...nestedCommands.splice(0));
+        statement();
+        compoundEnd = !header();
+        dangling = false;
+        index = expression.end;
+        segment = index + 1;
+        continue;
+      }
+      if (!words.length && !hasRedirect && !header() && (char === "(" || char === "{" && /[ \t\n]/.test(input[index + 1] ?? ""))) {
+        const group = bashDelimited(input, index, depth);
+        if (!group || !group.source.trim())
+          return { kind: "opaque", reason: "invalid-structure" };
+        const result = scanBash(group.source, depth + 1, budget);
+        if (result.kind === "opaque")
+          return result;
+        commands.push(...result.commands);
+        statement();
+        compoundEnd = true;
+        dangling = false;
+        index = group.end;
+        segment = index + 1;
+        continue;
+      }
+      if (!words.length && !hasRedirect && input.startsWith("[[", index)) {
+        const expression = bashExpansion(input, index, depth, "test");
+        if (!expression)
+          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;
+        continue;
+      }
+    }
     if (quote === "single") {
       wordStarted = true;
+      wordEnd = index + 1;
       if (char === "'")
         quote = undefined;
       else
@@ -136,28 +273,44 @@ function scanBash(input, depth) {
             word += next2;
         } else
           word += char;
-      } else if (char === "$" && input[index + 1] === "(" || char === "`") {
-        const substitution = bashSubstitution(input, index);
+      } 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 result = scanBash(substitution.source, depth + 1);
-        if (result.kind === "opaque")
-          return result;
-        nestedCommands.push(...result.commands.map(markNested));
+        const failure = addSubstitutions(substitution);
+        if (failure)
+          return failure;
         word += input.slice(index, substitution.end + 1);
         index = substitution.end;
-      } else {
-        if (char === "$" && /^\$\{[^}:@]+@P\}/.test(input.slice(index)))
-          return { kind: "opaque", reason: "dynamic-execution" };
-        if (char === "$" && /^\$\{\([^)]*e[^)]*\)/.test(input.slice(index)))
-          return { kind: "opaque", reason: "dynamic-execution" };
+      } 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;
@@ -165,6 +318,7 @@ function scanBash(input, depth) {
     if (char === '"') {
       quote = "double";
       wordStarted = true;
+      wordEnd = index + 1;
       if (!assignmentWord)
         assignmentHeadUnsafe = true;
       continue;
@@ -172,60 +326,56 @@ function scanBash(input, depth) {
     if (char === "\\") {
       if (index + 1 >= input.length)
         return { kind: "opaque", reason: "unterminated-escape" };
-      wordStarted = true;
       if (input[index + 1] === `
 `)
         index++;
       else {
+        wordStarted = true;
         if (!assignmentWord)
           assignmentHeadUnsafe = true;
         word += input[++index];
+        wordEnd = index + 1;
       }
       continue;
     }
-    if (char === "$" && input[index + 1] === "(" || char === "`") {
-      const substitution = bashSubstitution(input, index);
+    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 result = scanBash(substitution.source, depth + 1);
-      if (result.kind === "opaque")
-        return result;
-      nestedCommands.push(...result.commands.map(markNested));
+      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 === ">") && input[index + 1] === "(") {
-      const substitution = bashParenthesized(input, index + 1);
+    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 result = scanBash(substitution.source, depth + 1);
-      if (result.kind === "opaque")
-        return result;
-      nestedCommands.push(...result.commands.map(markNested));
+      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 === "$" && input[index + 1] === "{" && /^\$\{[^}:@]+@P\}/.test(input.slice(index)))
-      return { kind: "opaque", reason: "dynamic-execution" };
-    if (char === "$" && /^\$\{\([^)]*e[^)]*\)/.test(input.slice(index)))
-      return { kind: "opaque", reason: "dynamic-execution" };
-    if (char === "$" && input[index + 1] === "[")
-      return { kind: "opaque", reason: "dynamic-execution" };
-    if (char === "<" && input[index + 1] === "<")
-      heredoc = true;
     if (char === "#" && !wordStarted) {
-      finishCommand(index);
-      comment = index;
       const newline = input.indexOf(`
 `, index);
+      if (words.length > 0 || hasRedirect) {
+        finishCommand();
+        dangling = false;
+        inList = false;
+      }
       if (newline === -1)
         break;
-      index = newline;
-      segment = newline + 1;
+      index = newline - 1;
+      segment = newline;
       continue;
     }
     const redirect = "<>&".includes(char) ? BASH_REDIRECTS.find((candidate) => input.startsWith(candidate, index)) : undefined;
@@ -233,19 +383,43 @@ function scanBash(input, depth) {
       hasRedirect = true;
       if (redirectTarget)
         invalidRedirect = true;
-      if (wordStarted && /^\d+$/.test(word)) {
+      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;
       continue;
     }
-    if ("()".includes(char) || char === "!" && !wordStarted)
-      compound = true;
-    if (/\s/.test(char) && char !== `
-`) {
+    if (structures.at(-1)?.phase === "pattern" && (char === ")" || char === "|")) {
+      finishWord();
+      index--;
+      continue;
+    }
+    if ("()".includes(char))
+      return { kind: "opaque", reason: "compound-command" };
+    if (/\s/.test(char) && !` 	
+`.includes(char))
+      return { kind: "opaque", reason: "invalid-structure" };
+    if (char === " " || char === "\t") {
       finishWord();
       continue;
     }
@@ -253,315 +427,578 @@ function scanBash(input, depth) {
     const separator = char === "&" && next === "&" || char === "|" && (next === "|" || next === "&") ? char + next : char === ";" || char === "|" || char === "&" || char === `
 ` ? char : undefined;
     if (separator) {
-      finishCommand(index, true);
-      if (redirectTarget)
-        invalidRedirect = true;
-      terminalBackground = separator === "&" || separator === ";" || 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;
+      }
+      finishCommand(true);
+      if (structure?.kind === "for" && structure.phase === "header")
+        structure.phase = "do";
+      dangling = separator !== "&" && separator !== ";" && separator !== `
 `;
+      inList = dangling;
+      if (separator === `
+` && heredocs.length) {
+        index--;
+        continue;
+      }
       index += separator.length - 1;
       segment = index + 1;
       continue;
     }
-    terminalBackground = false;
     wordStarted = true;
-    if (char === "=" && !assignmentHeadUnsafe && /^[A-Za-z_][A-Za-z0-9_]*\+?$/.test(word))
+    if (char === "=" && !assignmentHeadUnsafe && /^[A-Za-z_][A-Za-z0-9_]*(?:\[.*\])?\+?$/.test(word))
       assignmentWord = true;
     word += char;
+    wordEnd = index + 1;
   }
   if (quote)
     return { kind: "opaque", reason: "unterminated-quote" };
-  if (heredoc)
+  if (heredocs.length)
     return { kind: "opaque", reason: "heredoc" };
-  if (!terminalBackground && (comment === undefined || input.includes(`
-`, comment)))
-    finishCommand(input.length);
-  if (redirectTarget)
-    invalidRedirect = true;
-  if (separated && !terminalBackground && comment === undefined && !input.slice(segment).trim())
+  if (wordStarted || words.length > 0 || hasRedirect) {
+    finishCommand();
+    dangling = false;
+  }
+  if (dangling)
     invalidStructure = true;
   if (invalidStructure)
     return { kind: "opaque", reason: "invalid-structure" };
   if (invalidRedirect)
     return { kind: "opaque", reason: "invalid-redirect" };
-  const conditional = bashConditionalCommands(commands);
-  if (conditional)
-    commands.splice(0, commands.length, ...conditional);
-  if (compound || commands.some((command) => BASH_COMPOUND_KEYWORDS.has(command.words[0] ?? "")))
+  if (structures.length)
     return { kind: "opaque", reason: "compound-command" };
-  if (commands.some((command) => /[$`]/.test(command.words[0] ?? "")))
-    return { kind: "opaque", reason: "dynamic-command-name" };
-  if (commands.some((command) => command.words[0]?.startsWith("=")))
-    return { kind: "opaque", reason: "dynamic-command-name" };
   return { kind: "scanned", commands };
 }
-function bashConditionalCommands(commands) {
-  if (commands[0]?.words[0] !== "if" || commands.at(-1)?.words[0] !== "fi")
+function bashDelimited(input, start, depth) {
+  if (depth >= MAX_SUBSTITUTION_DEPTH)
     return;
-  const keywords = new Set(["if", "then", "elif", "else", "fi"]);
-  if (commands.some((command) => BASH_COMPOUND_KEYWORDS.has(command.words[0] ?? "") && !keywords.has(command.words[0])))
-    return;
-  const normalized = [];
-  let phase = "condition";
-  let hasCommand = false;
-  let sawElse = false;
-  for (const [index, command] of commands.entries()) {
-    const keyword = command.words[0];
-    if (!keywords.has(keyword ?? "")) {
-      normalized.push(command);
-      hasCommand = true;
-      continue;
-    }
-    const offset = command.resource.indexOf(keyword) + keyword.length;
-    const inline = command.words.length > 1 ? { resource: command.resource.slice(offset).trim(), words: command.words.slice(1) } : undefined;
-    if (index === 0) {
-      if (inline)
-        normalized.push(inline);
-      hasCommand = Boolean(inline);
-      continue;
-    }
-    if (keyword === "then") {
-      if (phase !== "condition" || !hasCommand)
-        return;
-      phase = "body";
-      hasCommand = Boolean(inline);
+  const close = input[start] === "{" ? "}" : ")";
+  const cases = [];
+  const heredocs = [];
+  let commandStart = true;
+  for (let index = start + 1;index < input.length; index++) {
+    const char = input[index];
+    if (char === "\\") {
+      if (input[index + 1] !== `
+`)
+        commandStart = false;
+      index++;
+      continue;
     }
-    if (keyword === "elif") {
-      if (phase !== "body" || !hasCommand || sawElse)
+    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;
-      phase = "condition";
-      hasCommand = Boolean(inline);
+      index = nested.end;
+      continue;
     }
-    if (keyword === "else") {
-      if (phase !== "body" || !hasCommand || sawElse)
+    const boundary = index === start + 1 || /[ \t\n;|&(){}]/.test(input[index - 1]);
+    if (char === "#" && boundary) {
+      const newline = input.indexOf(`
+`, index);
+      if (newline < 0)
         return;
-      phase = "else";
-      sawElse = true;
-      hasCommand = Boolean(inline);
+      index = newline - 1;
+      continue;
     }
-    if (keyword === "fi") {
-      if (index !== commands.length - 1 || phase === "condition" || !hasCommand || inline)
+    if (input.startsWith("<<<", index)) {
+      index += 2;
+      continue;
+    }
+    if (input.startsWith("<<", index)) {
+      const delimiter = bashHeredocDelimiter(input, index);
+      if (!delimiter)
         return;
+      heredocs.push(delimiter);
+      index = delimiter.end;
       continue;
     }
-    if (inline)
-      normalized.push(inline);
-  }
-  return normalized;
-}
-function bashLeadingGroup(input) {
-  const start = input.search(/\S/);
-  if (start < 0)
-    return;
-  if (input[start] === "{") {
-    const group = bashBraced(input, start);
-    if (!group)
-      return;
-    const source = group.source.trim();
-    if (!source.endsWith(";"))
-      return;
-    return { source: source.slice(0, -1), end: group.end };
-  }
-  if (input[start] !== "(")
-    return;
-  return bashParenthesized(input, start);
-}
-function bashBraced(input, start) {
-  let quote;
-  let level = 1;
-  for (let index = start + 1;index < input.length; index++) {
-    const char = input[index];
-    if (quote === "single") {
-      if (char === "'")
-        quote = undefined;
+    if (char === `
+` && heredocs.length) {
+      for (const heredoc of heredocs.splice(0)) {
+        const body = bashHeredoc(input, index + 1, heredoc);
+        if (!body)
+          return;
+        index = body.end;
+      }
+      commandStart = true;
       continue;
     }
-    if (char === "\\") {
-      index++;
+    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 (char === "'") {
-      quote = "single";
+    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 (char === '"') {
-      quote = quote === "double" ? undefined : "double";
+    if (input.startsWith("((", index)) {
+      const nested = bashExpansion(input, index, depth + 1, "arithmetic");
+      if (!nested)
+        return;
+      index = nested.end;
+      commandStart = false;
       continue;
     }
-    if (char === "{" && quote !== "double")
-      level++;
-    if (char !== "}" || quote === "double" || --level)
+    if (char === "(" || char === "{" && boundary && /[ \t\n]/.test(input[index + 1] ?? "")) {
+      const nested = bashDelimited(input, index, depth + 1);
+      if (!nested)
+        return;
+      index = nested.end;
+      commandStart = false;
       continue;
-    return { source: input.slice(start + 1, index), end: index };
+    }
+    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 bashParenthesized(input, start) {
-  let quote;
-  let level = 1;
-  for (let index = start + 1;index < input.length; index++) {
+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 (quote === "single") {
-      if (char === "'")
-        quote = undefined;
+    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++;
       continue;
     }
-    if (char === "\\") {
-      index++;
+    if ((char === "'" || input.startsWith("$'", index)) && kind !== "double" && kind !== "heredoc" && !arithmetic && !(kind === "parameter" && quoted)) {
+      const end = char === "'" ? input.indexOf("'", index + 1) : bashAnsiQuote(input, index + 1)?.end;
+      if (end === undefined || end < 0)
+        return;
+      index = end;
       continue;
     }
-    if (char === "'") {
-      quote = "single";
+    if (char === '"' && kind !== "heredoc") {
+      const nested = bashExpansion(input, index, depth + 1, "double");
+      if (!nested)
+        return;
+      substitutions.push(...nested.substitutions);
+      index = nested.end;
       continue;
     }
-    if (char === '"') {
-      quote = quote === "double" ? undefined : "double";
+    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 (char === "(" && quote !== "double")
-      level++;
-    if (char !== ")" || quote === "double" || --level)
+    if (kind === "array" && "<>=".includes(char) && input[index + 1] === "(") {
+      const nested = bashDelimited(input, index + 1, depth + 1);
+      if (!nested)
+        return;
+      substitutions.push(nested.source);
+      index = nested.end;
+      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;
       continue;
-    return { source: input.slice(start + 1, index), end: index };
+    }
+    if (!mode && kind === "arithmetic" && char === ";")
+      return;
   }
+  if (kind === "heredoc")
+    return { source: input.slice(start), end: input.length - 1, substitutions };
 }
-function bashSubstitution(input, start) {
-  if (input[start] === "`") {
-    for (let index = start + 1;index < input.length; index++) {
-      if (input[index] === "\\")
-        index++;
-      else if (input[index] === "`")
-        return { source: input.slice(start + 1, index).replaceAll("\\`", "`"), end: index };
+function bashAnsiQuote(input, start) {
+  let value = "";
+  for (let index = start + 1;index < input.length; index++) {
+    if (input[index] === "'")
+      return { value, end: index };
+    if (input[index] !== "\\") {
+      value += input[index];
+      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);
+      }
     }
-    return;
   }
-  if (input.slice(start, start + 3) === "$((")
-    return;
+}
+function bashHeredocDelimiter(input, start) {
+  const tabs = input[start + 2] === "-";
+  let delimiter = "";
+  let quoted = false;
   let quote;
-  let level = 1;
-  for (let index = start + 2;index < input.length; index++) {
+  let end = start;
+  let started = false;
+  for (let index = start + (tabs ? 3 : 2);index < input.length; index++) {
     const char = input[index];
-    if (quote === "single") {
-      if (char === "'")
-        quote = undefined;
+    if (!started && /[ \t]/.test(char))
       continue;
-    }
-    if (char === "\\") {
-      index++;
+    if (!started && char === "#")
+      return;
+    if (!quote && /[ \t\n;&|()<>]/.test(char))
+      return started ? { delimiter, quoted, tabs, end } : undefined;
+    if (!quote && input.startsWith("$'", index)) {
+      const literal = bashAnsiQuote(input, index + 1);
+      if (!literal)
+        return;
+      delimiter += literal.value;
+      quoted = true;
+      started = true;
+      index = literal.end;
+      end = index;
       continue;
     }
-    if (char === "'") {
-      quote = "single";
+    if (!quote && input.startsWith('$"', index)) {
+      quote = '"';
+      quoted = true;
+      started = true;
+      end = ++index;
       continue;
     }
-    if (quote !== "double" && char === "#" && (index === start + 2 || /[\s;&|()]/.test(input[index - 1] ?? "")))
-      return;
-    if (char === '"') {
-      quote = quote === "double" ? undefined : "double";
+    if (char === quote) {
+      quote = undefined;
+      end = index;
       continue;
     }
-    if (char === "`" && quote !== "double") {
-      const nested = bashSubstitution(input, index);
-      if (!nested)
+    if (char === "\\" && quote !== "'") {
+      const next = input[index + 1];
+      if (next === undefined)
         return;
-      index = nested.end;
-      continue;
-    }
-    if (quote === "double") {
-      if (char === "$" && input[index + 1] === "(") {
-        level++;
+      if (next === `
+`) {
         index++;
-      } else if (char === ")" && level > 1)
-        level--;
+        continue;
+      }
+      if (!quote || '$`"\\'.includes(next)) {
+        quoted = true;
+        started = true;
+        delimiter += input[++index];
+        end = index;
+        continue;
+      }
+    }
+    if (!quote && (char === "'" || char === '"')) {
+      quote = char;
+      quoted = true;
+      started = true;
+      end = index;
       continue;
     }
-    if (char === "(")
-      level++;
-    if (char !== ")" || --level)
+    delimiter += char;
+    started = true;
+    end = index;
+  }
+  if (started && !quote)
+    return { delimiter, quoted, tabs, end };
+}
+function bashHeredoc(input, start, delimiter) {
+  const bodyStart = start;
+  let lineStart = start;
+  let line = "";
+  for (let index = start;index <= input.length; index++) {
+    if (index < input.length && input[index] !== `
+`)
       continue;
-    return { source: input.slice(start + 2, index), end: index };
+    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);
+      start = index + 1;
+      continue;
+    }
+    if (line === delimiter.delimiter)
+      return { source: input.slice(bodyStart, lineStart), end: index };
+    line = "";
+    start = index + 1;
+    lineStart = start;
   }
 }
 function scanPowerShell(input) {
-  return scanPowerShellNested(input, 0);
+  return scanPowerShellNested(input, 0, { remaining: MAX_INPUT_LENGTH * MAX_SUBSTITUTION_DEPTH });
 }
-function scanPowerShellNested(input, depth) {
-  if (input.length > MAX_BASH_INPUT_LENGTH || depth >= 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)
+    return { kind: "opaque", reason: "invalid-structure" };
+  if (/[\0\u0085\u2013-\u2015\u2018-\u201e\ufeff]/.test(input))
     return { kind: "opaque", reason: "invalid-structure" };
   const commands = [];
   const nestedCommands = [];
   const words = [];
+  const rawWords = [];
+  const wordEnds = [];
   let segment = 0;
   let word = "";
   let started = false;
+  let wordStart = 0;
   let quote;
-  let dynamic = false;
+  let standalone = false;
+  let expression = hash;
+  let compound = false;
+  let stopParsing = false;
+  let commandEnd = 0;
+  let statementHead = true;
   let invalid = false;
   let redirectTarget = false;
   let comment = false;
-  let separated = false;
   let dangling = false;
-  const finishWord = () => {
+  let invocation = false;
+  const finishWord = (end) => {
     if (!started)
       return;
-    if (!redirectTarget)
+    if (word === "--%" && words.length > 0 && !expression && !/['"]/.test(input[wordStart]))
+      stopParsing = true;
+    if (!redirectTarget) {
+      if (!words.length && !invocation && !expression)
+        segment = wordStart;
       words.push(word);
+      rawWords.push(input.slice(wordStart, end));
+      wordEnds.push(end);
+      dangling = false;
+    }
+    commandEnd = end;
     redirectTarget = false;
     word = "";
     started = false;
   };
-  const finishCommand = (end, boundary = false) => {
-    finishWord();
-    const resource = input.slice(segment, end).trim();
-    if (resource)
-      commands.push({ resource, words: [...words] });
-    else if (boundary && separated)
+  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)
+      commands.push({
+        resource,
+        words: [...words],
+        rawWords: [...rawWords],
+        wordEnds: wordEnds.map((end2) => end2 - start),
+        ...statementHead && !invocation ? { statementHead: true } : {}
+      });
+    else if (!expression && invocation || required && !words.length && !nestedCommands.length)
+      invalid = true;
+    if (redirectTarget)
       invalid = true;
     commands.push(...nestedCommands.splice(0));
     words.length = 0;
-    separated ||= Boolean(resource);
+    rawWords.length = 0;
+    wordEnds.length = 0;
+    redirectTarget = false;
+    invocation = false;
+    expression = hash;
+    compound = false;
+    stopParsing = false;
   };
   for (let index = 0;index < input.length; index++) {
     const char = input[index];
-    if (quote) {
+    if (!started)
+      wordStart = index;
+    if (stopParsing) {
+      const stop = powerShellStopParsing(input, index);
+      const text = input.slice(index, stop).trim();
+      if (text) {
+        wordStart = index + input.slice(index, stop).search(/\S/);
+        word = text;
+        started = true;
+        finishWord(wordStart + text.length);
+      }
+      stopParsing = false;
+      index = stop - 1;
+      continue;
+    }
+    if (quote === "single") {
       started = true;
-      if (quote === "single" && char === "'" && input[index + 1] === "'") {
+      if (char === "'" && input[index + 1] === "'") {
         word += "'";
         index++;
-      } else if (quote === "single" && char === "'" || quote === "double" && char === '"')
+      } else if (char === "'") {
         quote = undefined;
-      else if (char === "`" && index + 1 < input.length)
-        word += input[++index];
-      else {
-        if (quote === "double" && char === "$" && input[index + 1] === "(")
-          dynamic = true;
+        if (standalone)
+          finishWord(index + 1);
+      } else
+        word += char;
+      continue;
+    }
+    if (quote === "double") {
+      if (char === '"' && input[index + 1] === '"') {
+        word += '"';
+        index++;
+      } else if (char === '"') {
+        quote = undefined;
+        if (standalone)
+          finishWord(index + 1);
+      } else if (char === "`") {
+        const escape = powerShellEscape(input, index);
+        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)
+          return { kind: "opaque", reason: "invalid-structure" };
+        const result = scanPowerShellNested(block.source, depth + 1, budget);
+        if (result.kind === "opaque")
+          return result;
+        nestedCommands.push(...result.commands);
+        word += input.slice(index, block.end + 1);
+        index = block.end;
+      } else
         word += char;
-      }
       continue;
     }
     if (char === "'" || char === '"') {
+      if (!started && words.length === 0 && !invocation)
+        expression = true;
       quote = char === "'" ? "single" : "double";
+      standalone = !started;
       started = true;
       continue;
     }
-    if (char === "`" && index + 1 < input.length) {
-      if (input[index + 1] === "\r" || input[index + 1] === `
-`)
-        return { kind: "opaque", reason: "invalid-structure" };
-      if (";&|".includes(input[index + 1]))
-        return { kind: "opaque", reason: "invalid-structure" };
-      if (words.length === 0)
-        dynamic = true;
+    if (char === "`") {
+      const escape = powerShellEscape(input, index);
+      if (!escape)
+        return { kind: "opaque", reason: "unterminated-escape" };
+      if (started || /\S/.test(escape.value)) {
+        started = true;
+        word += escape.value;
+      }
+      index = escape.end;
+      continue;
+    }
+    if (!started && words.length > 0 && !expression && /^--%(?=$|[\s;|&(){}])/.test(input.slice(index))) {
+      word = "--%";
       started = true;
-      word += input[++index];
+      finishWord(index + 3);
+      stopParsing = true;
+      index += 2;
       continue;
     }
-    if (char === "`")
-      return { kind: "opaque", reason: "unterminated-escape" };
-    if (char === "<" && input[index + 1] === "#")
-      return { kind: "opaque", reason: "dynamic-execution" };
-    if (char === "#" && !started) {
-      if (/^#requires\b/i.test(input.slice(index)))
-        return { kind: "opaque", reason: "dynamic-execution" };
-      finishCommand(index);
+    if (char === "<" && input[index + 1] === "#" && !started) {
+      const end = powerShellComment(input, index);
+      if (end === undefined)
+        return { kind: "opaque", reason: "invalid-structure" };
+      if (!words.length && !invocation)
+        segment = end + 1;
+      index = end;
+      continue;
+    }
+    if (char === "#" && (!started || expression)) {
+      if (words.length || started || invocation)
+        finishCommand(index);
+      statementHead = !dangling;
       comment = true;
       const endings = [input.indexOf(`
 `, index), input.indexOf("\r", index)].filter((ending) => ending >= 0);
@@ -571,40 +1008,130 @@ function scanPowerShellNested(input, depth) {
       comment = false;
       index = input[newline] === "\r" && input[newline + 1] === `
 ` ? newline + 1 : newline;
-      segment = newline + 1;
+      segment = index + 1;
       continue;
     }
-    const redirect = char === ">" || !started && (char === "*" || /\d/.test(char)) ? powerShellRedirect(input, index) : undefined;
+    const redirect = !started && (char === ">" || char === "*" || /\d/.test(char)) ? powerShellRedirect(input, index) : undefined;
+    if (redirect === false)
+      return { kind: "opaque", reason: "invalid-redirect" };
     if (redirect) {
-      finishWord();
+      if (redirectTarget)
+        return { kind: "opaque", reason: "invalid-redirect" };
+      if (words.length === 0)
+        return { kind: "opaque", reason: "invalid-redirect" };
       redirectTarget = !redirect.includes("&");
       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;
+        continue;
+      }
+      if (keyword === "foreach" && /^foreach\s*\(/i.test(input.slice(index))) {
+        expression = true;
+        compound = true;
+        index += keyword.length - 1;
+        continue;
+      }
+      if (keyword && /^(?:return|throw|exit|break|continue)$/.test(keyword)) {
+        index += keyword.length - 1;
+        segment = index + 1;
+        continue;
+      }
+    }
+    if (expression && !compound && (char === "=" || /[-+*/%]/.test(char) && input[index + 1] === "=")) {
+      finishWord(index);
+      words.length = 0;
+      rawWords.length = 0;
+      wordEnds.length = 0;
+      expression = false;
+      if (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 === "{" && !started) {
-      const block = powerShellBlock(input, index);
+    if (char === "@" && /['"]/.test(input[index + 1] ?? "")) {
+      const literal = powerShellHereString(input, index);
+      if (!literal)
+        return { kind: "opaque", reason: "unterminated-quote" };
+      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);
+      }
+      word = literal.source;
+      started = true;
+      index = literal.end;
+      finishWord(index + 1);
+      continue;
+    }
+    if (char === "$" && input[index + 1] === "{") {
+      const end = input.indexOf("}", index + 2);
+      if (end < 0)
+        return { kind: "opaque", reason: "invalid-structure" };
+      if (!started && !words.length && !invocation)
+        expression = true;
+      word += input.slice(index, end + 1);
+      started = true;
+      index = end;
+      continue;
+    }
+    const opener = (char === "$" || char === "@") && input[index + 1] === "(" ? index + 1 : char === "@" && input[index + 1] === "{" ? index + 1 : char === "(" || char === "{" || char === "[" && (expression || !started) ? index : undefined;
+    if (opener !== undefined) {
+      if (started && (char === "{" || char === "(")) {
+        finishWord(index);
+        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);
+      const result = scanPowerShellNested(block.source, depth + 1, budget, input[opener] === "[" || char === "@" && input[opener] === "{");
       if (result.kind === "opaque")
         return result;
-      nestedCommands.push(...result.commands.map(markNested));
+      nestedCommands.push(...result.commands);
       started = true;
       word += input.slice(index, block.end + 1);
       index = block.end;
+      if (input[opener] === "{" || char === "(")
+        finishWord(index + 1);
+      if (compound && input[opener] === "{") {
+        finishCommand(index + 1);
+        segment = index + 1;
+      }
       continue;
     }
-    if (char === "}")
+    if (char === "}" || char === ")")
       return { kind: "opaque", reason: "invalid-structure" };
-    if (char === "&" && !started && words.length === 0)
-      continue;
-    if (char === "." && !started && words.length === 0 && (/\s/.test(input[index + 1] ?? "") || !input[index + 1]))
+    if (!started && words.length === 0 && (char === "&" && input[index + 1] !== "&" || char === "." && (/\s/.test(input[index + 1] ?? "") || !input[index + 1]))) {
+      if (invocation)
+        return { kind: "opaque", reason: "invalid-structure" };
+      invocation = true;
       continue;
-    if ("@()".includes(char))
-      dynamic = true;
+    }
+    if (!started && !words.length && !invocation && powerShellExpression(input.slice(index)))
+      expression = true;
     if (/\s/.test(char) && char !== `
 ` && char !== "\r") {
-      finishWord();
+      finishWord(index);
       continue;
     }
     const next = input[index + 1];
@@ -612,14 +1139,22 @@ function scanPowerShellNested(input, depth) {
 ` ? char + next : char === "&" && next === "&" || char === "|" && next === "|" ? char + next : char === ";" || char === "|" || char === "&" || char === `
 ` || char === "\r" ? char : undefined;
     if (separator) {
-      finishCommand(index, true);
-      if (redirectTarget)
-        invalid = true;
+      if ((separator === `
+` || separator === "\r" || separator === `\r
+`) && !started && !words.length && !invocation) {
+        index += separator.length - 1;
+        segment = index + 1;
+        continue;
+      }
+      finishCommand(index, dangling || ![";", `
+`, "\r", `\r
+`].includes(separator));
       dangling = ![";", "&", `
 `, "\r", `\r
 `].includes(separator);
+      statementHead = !dangling;
       index += separator.length - 1;
-      segment = separator === "&" ? index : index + 1;
+      segment = index + 1;
       continue;
     }
     started = true;
@@ -632,76 +1167,263 @@ function scanPowerShellNested(input, depth) {
     finishCommand(input.length);
   if (redirectTarget || invalid || dangling)
     return { kind: "opaque", reason: "invalid-structure" };
-  const reason = dynamic ? "dynamic-execution" : commands.reduce((result, command) => result ?? powerShellOpaqueReason(command), undefined);
-  if (reason)
-    return { kind: "opaque", reason };
+  if (commands.some((command) => !command.words[0]))
+    return { kind: "opaque", reason: "dynamic-command-name" };
   return { kind: "scanned", commands };
 }
-function powerShellBlock(input, start) {
+function powerShellBlock(input, start, depth) {
+  if (depth >= MAX_SUBSTITUTION_DEPTH)
+    return;
   let quote;
-  let level = 1;
+  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] === "'")
+      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 === "'")
+      } 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 === "`") {
-      index++;
+      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 === "#" && quote !== "double") {
-      const newline = input.indexOf(`
-`, index);
+    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 (char === "<" && input[index + 1] === "#" && quote !== "double") {
-      const end = input.indexOf("#>", index + 2);
+    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;
-      index = end + 1;
+      if (head && !started)
+        expression = true;
+      index = end;
+      started = true;
       continue;
     }
-    if (char === "'") {
-      quote = "single";
+    if (!started && !head && !expression && /^--%(?=$|[\s;|&(){}])/.test(input.slice(index))) {
+      index = powerShellStopParsing(input, index + 3) - 1;
       continue;
     }
-    if (char === '"') {
-      quote = quote === "double" ? undefined : "double";
+    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 (char === "{" && quote !== "double")
-      level++;
-    if (char !== "}" || quote === "double" || --level)
+    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;
-    return { source: input.slice(start + 1, index), end: index };
+    }
+    if (head && !started && powerShellExpression(input.slice(index)))
+      expression = true;
+    started = true;
+    token += char;
   }
 }
-function shellCommandName(word) {
-  const value = (word ?? "").toLowerCase();
-  return value.slice(Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\")) + 1);
+var POWERSHELL_ESCAPES = {
+  "0": "\x00",
+  a: "\x07",
+  b: "\b",
+  e: "\x1B",
+  f: "\f",
+  n: `
+`,
+  r: "\r",
+  t: "\t",
+  v: "\v"
+};
+function powerShellEscape(input, start) {
+  const char = input[start + 1];
+  if (char === undefined)
+    return;
+  if (char === "\r" || char === `
+`)
+    return {
+      value: char === "\r" && input[start + 2] === `
+` ? `\r
+` : char,
+      end: start + (char === "\r" && input[start + 2] === `
+` ? 2 : 1)
+    };
+  if (char === "u" && input[start + 2] === "{") {
+    const code = /^u\{([0-9a-f]{1,6})\}/i.exec(input.slice(start + 1));
+    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: 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 powerShellStopParsing(input, start) {
+  let quoted = false;
+  for (let index = start;index < input.length; index++) {
+    if (input[index] === '"')
+      quoted = !quoted;
+    if (input[index] === "\r" || input[index] === `
+` || input[index] === "|" && !quoted)
+      return index;
+  }
+  return input.length;
 }
-function powerShellOpaqueReason(command) {
-  const head = command.words[0] ?? "";
-  if (head.includes("\\") && !/^[A-Za-z]:\\/.test(head) && !/^[A-Za-z_][A-Za-z0-9_.-]*\\[A-Za-z_][A-Za-z0-9_.-]*$/.test(head) || head.includes("$") || head.includes("@"))
-    return "dynamic-execution";
-  const name = shellCommandName(head);
-  if (["return", "throw", "exit", "break", "continue"].includes(name) && command.words.length > 1)
-    return "dynamic-execution";
-  if (!POWERSHELL_LOCATIONS.has(name))
+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));
+  if (!header)
     return;
-  if (command.words.some((word, index) => index > 0 && (word.includes("(") || word.includes("$") && !knownPowerShellDirectory(word) || /^[A-Za-z]+:/.test(word) && !/^[A-Za-z]:[\\/]/.test(word))))
-    return "dynamic-directory";
+  const body = start + header[0].length;
+  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] !== "@")
+      continue;
+    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 knownPowerShellDirectory(word) {
-  const variable = /^(?:\$(?:PWD|HOME|PSHOME)|\$env:[A-Za-z_][A-Za-z0-9_]*|\$\{env:[^}]+\})(?:[\\/]|$)/i.exec(word);
-  return Boolean(variable) && !word.slice(variable?.[0].length).includes("$");
+function powerShellExpansions(input, depth, budget) {
+  const commands = [];
+  for (let index = 0;index < input.length; index++) {
+    if (input[index] === "`") {
+      index++;
+      continue;
+    }
+    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;
+  }
+  return { kind: "scanned", commands };
 }
 function powerShellRedirect(input, index) {
   let cursor = index;
@@ -720,14 +1442,11 @@ function powerShellRedirect(input, index) {
     while (/\d/.test(input[cursor] ?? ""))
       cursor++;
   }
-  return input.slice(index, cursor);
-}
-function markNested(command) {
-  return Object.defineProperty({ ...command }, Nested, { value: true });
+  const redirect = input.slice(index, cursor);
+  return /^(?:(?:[1-6]|\*)?>>?|[2-6*]>&1)$/.test(redirect) ? redirect : false;
 }
 export {
   scanPowerShell,
   scan,
-  exports_scan as ShellScan,
-  Nested
+  exports_scan as ShellScan
 };