@opencode-ai/core 0.0.0-next-17400 → 0.0.0-next-17428

package/dist/chunks/wellknown-j1x99epj.js

@@ -0,0 +1,1022 @@
+import {
+  exports_select
+} from "./wellknown-04kwjb53.js";
+import {
+  __export
+} from "./wellknown-rvfvac9x.js";
+
+// src/shell/parse.ts
+var exports_parse = {};
+__export(exports_parse, {
+  scan: () => scan2,
+  ShellParse: () => exports_parse
+});
+import { Effect } from "effect";
+
+// ../shell-scan/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  scanPowerShell: () => scanPowerShell,
+  scan: () => scan,
+  ShellScan: () => exports_src
+});
+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"]);
+var POWERSHELL_ALIASES = {
+  "%": "foreach-object",
+  "?": "where-object",
+  ac: "add-content",
+  asnp: "add-pssnapin",
+  cli: "clear-item",
+  clc: "clear-content",
+  copy: "copy-item",
+  cp: "copy-item",
+  cpi: "copy-item",
+  del: "remove-item",
+  erase: "remove-item",
+  etsn: "enter-pssession",
+  foreach: "foreach-object",
+  icm: "invoke-command",
+  ihy: "invoke-history",
+  ii: "invoke-item",
+  ipal: "import-alias",
+  ipmo: "import-module",
+  ipsn: "import-pssession",
+  mi: "move-item",
+  move: "move-item",
+  mv: "move-item",
+  nal: "new-alias",
+  ni: "new-item",
+  nmo: "new-module",
+  r: "invoke-history",
+  rd: "remove-item",
+  ren: "rename-item",
+  ri: "remove-item",
+  rm: "remove-item",
+  rmdir: "remove-item",
+  rni: "rename-item",
+  rmo: "remove-module",
+  rsnp: "remove-pssnapin",
+  sajb: "start-job",
+  sal: "set-alias",
+  saps: "start-process",
+  sbp: "set-psbreakpoint",
+  sc: "set-content",
+  si: "set-item",
+  start: "start-process",
+  pushd: "push-location",
+  trcm: "trace-command",
+  where: "where-object"
+};
+var MAX_BASH_INPUT_LENGTH = 64 * 1024;
+var MAX_SUBSTITUTION_DEPTH = 32;
+function scan(input) {
+  return scanBash(input, 0);
+}
+function scanBash(input, depth) {
+  if (input.length > MAX_BASH_INPUT_LENGTH)
+    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 assignmentWords = [];
+  let word = "";
+  let wordStarted = false;
+  let assignmentWord = false;
+  let assignmentHeadUnsafe = false;
+  let segment = 0;
+  let quote;
+  let dynamicWord = false;
+  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;
+  const finishWord = () => {
+    if (!wordStarted)
+      return;
+    if (!redirectTarget) {
+      words.push(word);
+      assignmentWords.push(assignmentWord);
+    }
+    redirectTarget = false;
+    word = "";
+    wordStarted = false;
+    assignmentWord = false;
+    assignmentHeadUnsafe = false;
+  };
+  const finishCommand = (end, boundary = false) => {
+    finishWord();
+    const resource = input.slice(segment, end).trim();
+    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))
+      invalidStructure = true;
+    words.length = 0;
+    assignmentWords.length = 0;
+    separated = true;
+    hasRedirect = false;
+  };
+  for (let index = 0;index < input.length; index++) {
+    const char = input[index];
+    if (quote === "single") {
+      wordStarted = true;
+      if (char === "'")
+        quote = undefined;
+      else
+        word += char;
+      continue;
+    }
+    if (quote === "double") {
+      wordStarted = true;
+      if (char === '"')
+        quote = undefined;
+      else if (char === "\\" && index + 1 < input.length)
+        word += input[++index];
+      else if (char === "$" && input[index + 1] === "(" || char === "`") {
+        const substitution = bashSubstitution(input, index);
+        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);
+        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" };
+        if (char === "$")
+          dynamicWord = true;
+        word += char;
+      }
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      wordStarted = true;
+      if (!assignmentWord)
+        assignmentHeadUnsafe = true;
+      continue;
+    }
+    if (char === '"') {
+      quote = "double";
+      wordStarted = true;
+      if (!assignmentWord)
+        assignmentHeadUnsafe = true;
+      continue;
+    }
+    if (char === "\\") {
+      if (index + 1 >= input.length)
+        return { kind: "opaque", reason: "unterminated-escape" };
+      wordStarted = true;
+      if (input[index + 1] === `
+`)
+        index++;
+      else {
+        if (!assignmentWord)
+          assignmentHeadUnsafe = true;
+        word += input[++index];
+      }
+      continue;
+    }
+    if (char === "$" && input[index + 1] === "(" || char === "`") {
+      const substitution = bashSubstitution(input, index);
+      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);
+      wordStarted = true;
+      word += input.slice(index, substitution.end + 1);
+      index = substitution.end;
+      continue;
+    }
+    if ((char === "<" || char === ">") && input[index + 1] === "(") {
+      const substitution = bashParenthesized(input, index + 1);
+      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);
+      wordStarted = true;
+      word += input.slice(index, substitution.end + 1);
+      index = substitution.end;
+      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 (newline === -1)
+        break;
+      index = newline;
+      segment = newline + 1;
+      continue;
+    }
+    const redirect = /^(?:&>>?|<<<|<<-?|<>|<&|>&|>\||>>|>|<)/.exec(input.slice(index))?.[0];
+    if (redirect) {
+      hasRedirect = true;
+      if (redirectTarget)
+        invalidRedirect = true;
+      if (wordStarted && /^\d+$/.test(word)) {
+        word = "";
+        wordStarted = false;
+      } else
+        finishWord();
+      redirectTarget = true;
+      index += redirect.length - 1;
+      continue;
+    }
+    if ("()".includes(char) || char === "!" && !wordStarted)
+      compound = true;
+    if (/\s/.test(char) && char !== `
+`) {
+      finishWord();
+      continue;
+    }
+    const next = input[index + 1];
+    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 === `
+`;
+      index += separator.length - 1;
+      segment = index + 1;
+      continue;
+    }
+    terminalBackground = false;
+    wordStarted = true;
+    if (char === "$")
+      dynamicWord = true;
+    if (char === "=" && !assignmentHeadUnsafe && /^[A-Za-z_][A-Za-z0-9_]*\+?$/.test(word))
+      assignmentWord = true;
+    word += char;
+  }
+  if (quote)
+    return { kind: "opaque", reason: "unterminated-quote" };
+  if (heredoc)
+    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())
+    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] ?? "")))
+    return { kind: "opaque", reason: "compound-command" };
+  if (commands.some((command) => /[$`]/.test(command.words[0] ?? "")) || dynamicWord && commands[0]?.words[0]?.includes("$"))
+    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: commands.concat(nestedCommands) };
+}
+function bashConditionalCommands(commands) {
+  if (commands[0]?.words[0] !== "if" || commands.at(-1)?.words[0] !== "fi")
+    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);
+    }
+    if (keyword === "elif") {
+      if (phase !== "body" || !hasCommand || sawElse)
+        return;
+      phase = "condition";
+      hasCommand = Boolean(inline);
+    }
+    if (keyword === "else") {
+      if (phase !== "body" || !hasCommand || sawElse)
+        return;
+      phase = "else";
+      sawElse = true;
+      hasCommand = Boolean(inline);
+    }
+    if (keyword === "fi") {
+      if (index !== commands.length - 1 || phase === "condition" || !hasCommand || inline)
+        return;
+      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;
+      continue;
+    }
+    if (char === "\\") {
+      index++;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      continue;
+    }
+    if (char === '"') {
+      quote = quote === "double" ? undefined : "double";
+      continue;
+    }
+    if (char === "{" && quote !== "double")
+      level++;
+    if (char !== "}" || quote === "double" || --level)
+      continue;
+    return { source: input.slice(start + 1, index), end: index };
+  }
+}
+function bashParenthesized(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;
+      continue;
+    }
+    if (char === "\\") {
+      index++;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      continue;
+    }
+    if (char === '"') {
+      quote = quote === "double" ? undefined : "double";
+      continue;
+    }
+    if (char === "(" && quote !== "double")
+      level++;
+    if (char !== ")" || quote === "double" || --level)
+      continue;
+    return { source: input.slice(start + 1, index), end: index };
+  }
+}
+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 };
+    }
+    return;
+  }
+  if (input.slice(start, start + 3) === "$((")
+    return;
+  let quote;
+  let level = 1;
+  for (let index = start + 2;index < input.length; index++) {
+    const char = input[index];
+    if (quote === "single") {
+      if (char === "'")
+        quote = undefined;
+      continue;
+    }
+    if (char === "\\") {
+      index++;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      continue;
+    }
+    if (quote !== "double" && char === "#" && (index === start + 2 || /[\s;&|()]/.test(input[index - 1] ?? "")))
+      return;
+    if (char === '"') {
+      quote = quote === "double" ? undefined : "double";
+      continue;
+    }
+    if (char === "`" && quote !== "double") {
+      const nested = bashSubstitution(input, index);
+      if (!nested)
+        return;
+      index = nested.end;
+      continue;
+    }
+    if (quote === "double") {
+      if (char === "$" && input[index + 1] === "(") {
+        level++;
+        index++;
+      } else if (char === ")" && level > 1)
+        level--;
+      continue;
+    }
+    if (char === "(")
+      level++;
+    if (char !== ")" || --level)
+      continue;
+    return { source: input.slice(start + 2, index), end: index };
+  }
+}
+function scanPowerShell(input) {
+  return scanPowerShellNested(input, 0);
+}
+function scanPowerShellNested(input, depth) {
+  if (input.length > MAX_BASH_INPUT_LENGTH || depth >= MAX_SUBSTITUTION_DEPTH)
+    return { kind: "opaque", reason: "invalid-structure" };
+  const commands = [];
+  const nestedCommands = [];
+  const words = [];
+  let segment = 0;
+  let word = "";
+  let started = false;
+  let quote;
+  let dynamic = false;
+  let invalid = false;
+  let redirectTarget = false;
+  let comment = false;
+  let separated = false;
+  let dangling = false;
+  let dynamicDirectory = false;
+  const finishWord = () => {
+    if (!started)
+      return;
+    if (!redirectTarget)
+      words.push(word);
+    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)
+      invalid = true;
+    words.length = 0;
+    separated ||= Boolean(resource);
+  };
+  for (let index = 0;index < input.length; index++) {
+    const char = input[index];
+    if (quote) {
+      started = true;
+      if (quote === "single" && char === "'" && input[index + 1] === "'") {
+        word += "'";
+        index++;
+      } else if (quote === "single" && char === "'" || quote === "double" && char === '"')
+        quote = undefined;
+      else if (char === "`" && index + 1 < input.length)
+        word += input[++index];
+      else {
+        if (quote === "double" && char === "$" && input[index + 1] === "(")
+          dynamic = true;
+        word += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char === "'" ? "single" : "double";
+      started = true;
+      continue;
+    }
+    if (char === "`" && index + 1 < input.length) {
+      if (words.length === 0)
+        dynamic = true;
+      started = true;
+      if (input[index + 1] === "\r" && input[index + 2] === `
+`)
+        index += 2;
+      else if (input[index + 1] === "\r" || input[index + 1] === `
+`)
+        index++;
+      else
+        word += input[++index];
+      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);
+      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)
+        break;
+      comment = false;
+      index = input[newline] === "\r" && input[newline + 1] === `
+` ? newline + 1 : newline;
+      segment = newline + 1;
+      continue;
+    }
+    const redirect = powerShellRedirect(input, index);
+    if (redirect) {
+      finishWord();
+      redirectTarget = !redirect.includes("&");
+      index += redirect.length - 1;
+      continue;
+    }
+    if (char === "{" && !started) {
+      const block = powerShellBlock(input, index);
+      if (!block)
+        return { kind: "opaque", reason: "invalid-structure" };
+      const result = scanPowerShellNested(block.source, depth + 1);
+      if (result.kind === "opaque")
+        return result;
+      nestedCommands.push(...result.commands);
+      started = true;
+      word += input.slice(index, block.end + 1);
+      index = block.end;
+      continue;
+    }
+    if (char === "}")
+      return { kind: "opaque", reason: "invalid-structure" };
+    if ((char === "&" || char === ".") && !started && words.length === 0 && (/\s/.test(input[index + 1] ?? "") || !input[index + 1]))
+      continue;
+    if ("@()".includes(char))
+      dynamic = true;
+    if (/\s/.test(char) && char !== `
+` && char !== "\r") {
+      finishWord();
+      continue;
+    }
+    const next = input[index + 1];
+    const separator = char === "\r" && next === `
+` ? 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;
+      dangling = ![";", "&", `
+`, "\r", `\r
+`].includes(separator);
+      index += separator.length - 1;
+      segment = index + 1;
+      continue;
+    }
+    started = true;
+    dangling = false;
+    word += char;
+  }
+  if (quote)
+    return { kind: "opaque", reason: "unterminated-quote" };
+  if (!comment)
+    finishCommand(input.length);
+  if (redirectTarget || invalid || dangling)
+    return { kind: "opaque", reason: "invalid-structure" };
+  if (dynamic || commands.some((command) => {
+    const head = command.words[0] ?? "";
+    if (head.includes("\\") && !/^[A-Za-z]:\\/.test(head))
+      return true;
+    const rawName = shellCommandName(head);
+    const name = POWERSHELL_ALIASES[rawName] ?? rawName;
+    if (head.includes("$") || head.includes("@"))
+      return true;
+    if (["return", "throw", "exit", "break", "continue"].includes(name) && command.words.length > 1)
+      return true;
+    if (POWERSHELL_LOCATIONS.has(name ?? ""))
+      return dynamicDirectory = command.words.some((word2, index) => index > 0 && (word2.includes("(") || word2.includes("$") && !knownPowerShellDirectory(word2))) || command.words.some((word2, index) => index > 0 && /^[A-Za-z]+:/.test(word2) && !/^[A-Za-z]:[\\/]/.test(word2));
+    return false;
+  }))
+    return { kind: "opaque", reason: dynamicDirectory ? "dynamic-directory" : "dynamic-execution" };
+  return { kind: "scanned", commands: commands.concat(nestedCommands) };
+}
+function powerShellBlock(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 === "'" && input[index + 1] === "'")
+        index++;
+      else if (char === "'")
+        quote = undefined;
+      continue;
+    }
+    if (char === "`") {
+      index++;
+      continue;
+    }
+    if (char === "#" && quote !== "double") {
+      const newline = input.indexOf(`
+`, index);
+      if (newline < 0)
+        return;
+      index = newline;
+      continue;
+    }
+    if (char === "<" && input[index + 1] === "#" && quote !== "double") {
+      const end = input.indexOf("#>", index + 2);
+      if (end < 0)
+        return;
+      index = end + 1;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      continue;
+    }
+    if (char === '"') {
+      quote = quote === "double" ? undefined : "double";
+      continue;
+    }
+    if (char === "{" && quote !== "double")
+      level++;
+    if (char !== "}" || quote === "double" || --level)
+      continue;
+    return { source: input.slice(start + 1, index), end: index };
+  }
+}
+function shellCommandName(word) {
+  const value = (word ?? "").toLowerCase();
+  return value.slice(Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\")) + 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 powerShellRedirect(input, index) {
+  let cursor = index;
+  if (input[cursor] === "*")
+    cursor++;
+  else
+    while (/\d/.test(input[cursor] ?? ""))
+      cursor++;
+  if (input[cursor] !== ">" && input[cursor] !== "<")
+    return;
+  cursor++;
+  if (input[cursor] === ">")
+    cursor++;
+  if (input[cursor] === "&") {
+    cursor++;
+    while (/\d/.test(input[cursor] ?? ""))
+      cursor++;
+  }
+  return input.slice(index, cursor);
+}
+
+// src/shell/parse.ts
+import os from "os";
+import path from "path";
+var CWD = new Set(["cd", "chdir", "popd", "pushd", "push-location", "set-location", "sl"]);
+var POWERSHELL_PATH_FLAGS = new Set(["-literalpath", "-path"]);
+var ARITY = {
+  cat: 1,
+  cd: 1,
+  chmod: 1,
+  chown: 1,
+  cp: 1,
+  echo: 1,
+  env: 1,
+  export: 1,
+  grep: 1,
+  kill: 1,
+  killall: 1,
+  ln: 1,
+  ls: 1,
+  mkdir: 1,
+  mv: 1,
+  ps: 1,
+  pwd: 1,
+  rm: 1,
+  rmdir: 1,
+  sleep: 1,
+  source: 1,
+  tail: 1,
+  touch: 1,
+  unset: 1,
+  which: 1,
+  aws: 3,
+  az: 3,
+  bazel: 2,
+  brew: 2,
+  bun: 2,
+  "bun run": 3,
+  "bun x": 3,
+  cargo: 2,
+  "cargo add": 3,
+  "cargo run": 3,
+  cdk: 2,
+  cf: 2,
+  cmake: 2,
+  composer: 2,
+  consul: 2,
+  "consul kv": 3,
+  crictl: 2,
+  deno: 2,
+  "deno task": 3,
+  doctl: 3,
+  docker: 2,
+  "docker builder": 3,
+  "docker compose": 3,
+  "docker container": 3,
+  "docker image": 3,
+  "docker network": 3,
+  "docker volume": 3,
+  eksctl: 2,
+  "eksctl create": 3,
+  firebase: 2,
+  flyctl: 2,
+  gcloud: 3,
+  gh: 3,
+  git: 2,
+  "git config": 3,
+  "git remote": 3,
+  "git stash": 3,
+  go: 2,
+  gradle: 2,
+  helm: 2,
+  heroku: 2,
+  hugo: 2,
+  ip: 2,
+  "ip addr": 3,
+  "ip link": 3,
+  "ip netns": 3,
+  "ip route": 3,
+  kind: 2,
+  "kind create": 3,
+  kubectl: 2,
+  "kubectl kustomize": 3,
+  "kubectl rollout": 3,
+  kustomize: 2,
+  make: 2,
+  mc: 2,
+  "mc admin": 3,
+  minikube: 2,
+  mongosh: 2,
+  mysql: 2,
+  mvn: 2,
+  ng: 2,
+  npm: 2,
+  "npm exec": 3,
+  "npm init": 3,
+  "npm run": 3,
+  "npm view": 3,
+  npx: 2,
+  nvm: 2,
+  nx: 2,
+  openssl: 2,
+  "openssl req": 3,
+  "openssl x509": 3,
+  pip: 2,
+  pipenv: 2,
+  pnpm: 2,
+  "pnpm dlx": 3,
+  "pnpm exec": 3,
+  "pnpm run": 3,
+  poetry: 2,
+  podman: 2,
+  "podman container": 3,
+  "podman image": 3,
+  psql: 2,
+  pulumi: 2,
+  "pulumi stack": 3,
+  python: 2,
+  pyenv: 2,
+  rake: 2,
+  rbenv: 2,
+  "redis-cli": 2,
+  rustup: 2,
+  serverless: 2,
+  sfdx: 3,
+  skaffold: 2,
+  sls: 2,
+  sst: 2,
+  swift: 2,
+  systemctl: 2,
+  terraform: 2,
+  "terraform workspace": 3,
+  tmux: 2,
+  turbo: 2,
+  ufw: 2,
+  vault: 2,
+  "vault auth": 3,
+  "vault kv": 3,
+  vercel: 2,
+  volta: 2,
+  wp: 2,
+  yarn: 2,
+  "yarn dlx": 3,
+  "yarn run": 3
+};
+var scan2 = Effect.fn("ShellParse.scan")(function* (command, shell, cwd) {
+  return scanCommands(command, cwd, shell, exports_select.ps(shell));
+});
+function scanCommands(command, cwd, shell, powershell) {
+  const result = powershell ? exports_src.scanPowerShell(command) : exports_src.scan(command);
+  if (result.kind === "opaque")
+    return {
+      commands: [{ resource: command, save: command }],
+      directories: [],
+      opaque: true,
+      directoryUnknown: true
+    };
+  if (result.commands.some((item) => {
+    const name = powershell ? item.words[0]?.toLowerCase() : item.words[0];
+    if (!name || !CWD.has(name) || name === "popd" || name === "pop-location")
+      return false;
+    return directoryArgs(item.words, powershell, cwd, shell).length === 0;
+  }))
+    return { commands: [{ resource: command }], directories: [], opaque: true, directoryUnknown: true };
+  return result.commands.reduce((output, item) => {
+    const name = powershell ? item.words[0]?.toLowerCase() : item.words[0];
+    if (!name)
+      return output;
+    if (CWD.has(name)) {
+      output.directories.push(...directoryArgs(item.words, powershell, cwd, shell));
+      return output;
+    }
+    output.commands.push({ resource: item.resource, save: `${prefix(item.words).join(" ")} *` });
+    return output;
+  }, {
+    commands: [],
+    directories: [],
+    opaque: false
+  });
+}
+function directoryArgs(command, powershell, cwd, shell) {
+  if (!powershell) {
+    const values = command.slice(1).filter((part) => !part.startsWith("-")).map((part) => directoryArgument(part, powershell, cwd, shell)).filter((part) => part !== undefined);
+    if (command[0] === "cd" && (values.length !== 1 || !path.isAbsolute(values[0]) && Boolean(process.env.CDPATH)))
+      return [];
+    return values;
+  }
+  const directories = [];
+  let expectsPath = false;
+  for (const part of command.slice(1)) {
+    if (expectsPath) {
+      const value2 = directoryArgument(part, powershell, cwd, shell);
+      if (value2)
+        directories.push(value2);
+      expectsPath = false;
+      continue;
+    }
+    if (part.startsWith("-")) {
+      expectsPath = POWERSHELL_PATH_FLAGS.has(part.toLowerCase());
+      continue;
+    }
+    const value = directoryArgument(part, powershell, cwd, shell);
+    if (value)
+      directories.push(value);
+  }
+  return directories;
+}
+function directoryArgument(value, powershell, cwd, shell) {
+  const quote = value[0];
+  const text = (quote === '"' || quote === "'") && value.at(-1) === quote ? value.slice(1, -1) : value;
+  if (!powershell)
+    return expandKnownDirectory(text);
+  return expandKnownDirectory(text.replace(/\$\{env:([^}]+)\}/gi, (_, key) => environment(key) ?? "").replace(/\$env:([A-Za-z_][A-Za-z0-9_]*)/gi, (_, key) => environment(key) ?? "").replace(/\$(HOME|PWD|PSHOME)(?=$|[\\/])/gi, (_, key) => {
+    if (key.toUpperCase() === "HOME")
+      return os.homedir();
+    if (key.toUpperCase() === "PWD")
+      return cwd;
+    return path.dirname(shell);
+  }));
+}
+function expandKnownDirectory(value) {
+  if (value.includes("$") || value.includes("`") || value.startsWith("("))
+    return;
+  if (value === "~")
+    return os.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\"))
+    return path.join(os.homedir(), value.slice(2));
+  if (value.startsWith("~"))
+    return;
+  return value;
+}
+function environment(key) {
+  if (process.platform !== "win32")
+    return process.env[key];
+  const name = Object.keys(process.env).find((item) => item.toLowerCase() === key.toLowerCase());
+  return name ? process.env[name] : undefined;
+}
+function prefix(tokens) {
+  for (let length = tokens.length;length > 0; length--) {
+    const arity = ARITY[tokens.slice(0, length).join(" ")];
+    if (arity !== undefined)
+      return tokens.slice(0, arity);
+  }
+  return tokens.slice(0, 1);
+}
+
+export { scan2 as scan, exports_parse };