Commit 99ffe34

@@ -0,0 +1,151 @@
+THIRD PARTY LICENSES
+
+@nodelib/fs.scandir@2.1.5
+  <unknown>
+  https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.scandir
+  MIT
+
+@nodelib/fs.stat@2.0.5
+  <unknown>
+  https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.stat
+  MIT
+
+@nodelib/fs.walk@1.2.8
+  <unknown>
+  https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.walk
+  MIT
+
+@sindresorhus/merge-streams@2.3.0
+  Sindre Sorhus <sindresorhus@gmail.com>
+  sindresorhus/merge-streams
+  MIT
+
+@webpod/ps@0.1.0
+  <unknown>
+  git://github.com/webpod/ps.git
+  MIT
+
+braces@3.0.3
+  Jon Schlinkert (https://github.com/jonschlinkert)
+  micromatch/braces
+  MIT
+
+chalk@5.4.1
+  <unknown>
+  chalk/chalk
+  MIT
+
+create-require@1.1.1
+  Maël Nison <nison.mael@gmail.com>, Paul Soporan <paul.soporan@gmail.com>, Pooya Parsa <pyapar@gmail.com>
+  nuxt-contrib/create-require
+  MIT
+
+envapi@0.2.3
+  Anton Golub <antongolub@antongolub.com>
+  git+https://github.com/webpod/envapi.git
+  MIT
+
+fast-glob@3.3.3
+  Denis Malinochkin <undefined>
+  mrmlnc/fast-glob
+  MIT
+
+fastq@1.19.0
+  Matteo Collina <hello@matteocollina.com>
+  git+https://github.com/mcollina/fastq.git
+  ISC
+
+fill-range@7.1.1
+  Jon Schlinkert (https://github.com/jonschlinkert)
+  jonschlinkert/fill-range
+  MIT
+
+fs-extra@11.2.0
+  JP Richardson <jprichardson@gmail.com>
+  https://github.com/jprichardson/node-fs-extra
+  MIT
+
+glob-parent@5.1.2
+  Gulp Team <team@gulpjs.com> (https://gulpjs.com/)
+  gulpjs/glob-parent
+  ISC
+
+globby@14.0.2
+  Sindre Sorhus <sindresorhus@gmail.com>
+  sindresorhus/globby
+  MIT
+
+graceful-fs@4.2.11
+  <unknown>
+  https://github.com/isaacs/node-graceful-fs
+  ISC
+
+is-glob@4.0.3
+  Jon Schlinkert (https://github.com/jonschlinkert)
+  micromatch/is-glob
+  MIT
+
+isexe@3.1.1
+  Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)
+  https://github.com/isaacs/isexe
+  ISC
+
+jsonfile@6.1.0
+  JP Richardson <jprichardson@gmail.com>
+  git@github.com:jprichardson/node-jsonfile.git
+  MIT
+
+merge2@1.4.1
+  <unknown>
+  git@github.com:teambition/merge2.git
+  MIT
+
+micromatch@4.0.8
+  Jon Schlinkert (https://github.com/jonschlinkert)
+  micromatch/micromatch
+  MIT
+
+node-fetch-native@1.6.4
+  <unknown>
+  unjs/node-fetch-native
+  MIT
+
+path-type@5.0.0
+  Sindre Sorhus <sindresorhus@gmail.com>
+  sindresorhus/path-type
+  MIT
+
+picomatch@2.3.1
+  Jon Schlinkert (https://github.com/jonschlinkert)
+  micromatch/picomatch
+  MIT
+
+run-parallel@1.2.0
+  Feross Aboukhadijeh <feross@feross.org>
+  git://github.com/feross/run-parallel.git
+  MIT
+
+to-regex-range@5.0.1
+  Jon Schlinkert (https://github.com/jonschlinkert)
+  micromatch/to-regex-range
+  MIT
+
+unicorn-magic@0.1.0
+  Sindre Sorhus <sindresorhus@gmail.com>
+  sindresorhus/unicorn-magic
+  MIT
+
+which@5.0.0
+  GitHub Inc.
+  git+https://github.com/npm/node-which.git
+  ISC
+
+yaml@2.7.0
+  Eemeli Aro <eemeli@gmail.com>
+  github:eemeli/yaml
+  ISC
+
+zurk@0.10.2
+  Anton Golub <antongolub@antongolub.com>
+  git+https://github.com/webpod/zurk.git
+  MIT

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+"use strict";
+const {
+  __export,
+  __toESM,
+  __toCommonJS,
+  __async
+} = require('./esblib.cjs');
+
+const import_meta_url =
+  typeof document === 'undefined'
+    ? new (require('url').URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href
+
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  argv: () => argv,
+  injectGlobalRequire: () => injectGlobalRequire,
+  isMain: () => isMain,
+  main: () => main,
+  normalizeExt: () => normalizeExt,
+  printUsage: () => printUsage,
+  transformMarkdown: () => transformMarkdown
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_url = __toESM(require("url"), 1);
+var import_index = require("./index.cjs");
+var import_deps = require("./deps.cjs");
+
+// src/repl.ts
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_node_repl = __toESM(require("repl"), 1);
+var import_node_util = require("util");
+var import_core = require("./core.cjs");
+var import_vendor_core = require("./vendor-core.cjs");
+var _a;
+var HISTORY = (_a = process.env.ZX_REPL_HISTORY) != null ? _a : import_node_path.default.join(import_node_os.default.homedir(), ".zx_repl_history");
+function startRepl() {
+  return __async(this, arguments, function* (history = HISTORY) {
+    import_core.defaults.verbose = false;
+    const r = import_node_repl.default.start({
+      prompt: import_vendor_core.chalk.greenBright.bold("\u276F "),
+      useGlobal: true,
+      preview: false,
+      writer(output) {
+        return output instanceof import_core.ProcessOutput ? output.toString().trimEnd() : (0, import_node_util.inspect)(output, { colors: true });
+      }
+    });
+    r.setupHistory(history, () => {
+    });
+  });
+}
+
+// src/cli.ts
+var import_util2 = require("./util.cjs");
+
+// src/md.ts
+var import_util = require("./util.cjs");
+function transformMarkdown(buf) {
+  var _a2;
+  const output = [];
+  const tabRe = /^(  +|\t)/;
+  const codeBlockRe = new RegExp("^(?<fence>(`{3,20}|~{3,20}))(?:(?<js>(js|javascript|ts|typescript))|(?<bash>(sh|shell|bash))|.*)$");
+  let state = "root";
+  let codeBlockEnd = "";
+  let prevLineIsEmpty = true;
+  for (const line of (0, import_util.bufToString)(buf).split(/\r?\n/)) {
+    switch (state) {
+      case "root":
+        if (tabRe.test(line) && prevLineIsEmpty) {
+          output.push(line);
+          state = "tab";
+          continue;
+        }
+        const { fence, js, bash } = ((_a2 = line.match(codeBlockRe)) == null ? void 0 : _a2.groups) || {};
+        if (!fence) {
+          prevLineIsEmpty = line === "";
+          output.push("// " + line);
+          continue;
+        }
+        codeBlockEnd = fence;
+        if (js) {
+          state = "js";
+          output.push("");
+        } else if (bash) {
+          state = "bash";
+          output.push("await $`");
+        } else {
+          state = "other";
+          output.push("");
+        }
+        break;
+      case "tab":
+        if (line === "") {
+          output.push("");
+        } else if (tabRe.test(line)) {
+          output.push(line);
+        } else {
+          output.push("// " + line);
+          state = "root";
+        }
+        break;
+      case "js":
+        if (line === codeBlockEnd) {
+          output.push("");
+          state = "root";
+        } else {
+          output.push(line);
+        }
+        break;
+      case "bash":
+        if (line === codeBlockEnd) {
+          output.push("`");
+          state = "root";
+        } else {
+          output.push(line);
+        }
+        break;
+      case "other":
+        if (line === codeBlockEnd) {
+          output.push("");
+          state = "root";
+        } else {
+          output.push("// " + line);
+        }
+        break;
+    }
+  }
+  return output.join("\n");
+}
+
+// src/cli.ts
+var import_vendor = require("./vendor.cjs");
+var import_meta = {};
+var EXT = ".mjs";
+var EXT_RE = /^\.[mc]?[jt]sx?$/;
+isMain() && main().catch((err) => {
+  if (err instanceof import_index.ProcessOutput) {
+    console.error("Error:", err.message);
+  } else {
+    console.error(err);
+  }
+  process.exitCode = 1;
+});
+function printUsage() {
+  console.log(`
+ ${import_index.chalk.bold("zx " + import_index.VERSION)}
+   A tool for writing better scripts
+
+ ${import_index.chalk.bold("Usage")}
+   zx [options] <script>
+
+ ${import_index.chalk.bold("Options")}
+   --quiet              suppress any outputs
+   --verbose            enable verbose mode
+   --shell=<path>       custom shell binary
+   --prefix=<command>   prefix all commands
+   --postfix=<command>  postfix all commands
+   --prefer-local, -l   prefer locally installed packages and binaries
+   --cwd=<path>         set current directory
+   --eval=<js>, -e      evaluate script
+   --ext=<.mjs>         script extension
+   --install, -i        install dependencies
+   --registry=<URL>     npm registry, defaults to https://registry.npmjs.org/
+   --version, -v        print current zx version
+   --help, -h           print help
+   --repl               start repl
+   --env=<path>         path to env file
+   --experimental       enables experimental features (deprecated)
+
+ ${import_index.chalk.italic("Full documentation:")} ${import_index.chalk.underline("https://google.github.io/zx/")}
+`);
+}
+var argv = (0, import_index.parseArgv)(process.argv.slice(2), {
+  default: { ["prefer-local"]: false },
+  // exclude 'prefer-local' to let minimist infer the type
+  string: ["shell", "prefix", "postfix", "eval", "cwd", "ext", "registry", "env"],
+  boolean: ["version", "help", "quiet", "verbose", "install", "repl", "experimental"],
+  alias: { e: "eval", i: "install", v: "version", h: "help", l: "prefer-local", "env-file": "env" },
+  stopEarly: true,
+  parseBoolean: true,
+  camelCase: true
+}, (0, import_index.resolveDefaults)({}, "ZX_", process.env, /* @__PURE__ */ new Set(["env", "install", "registry"])));
+function main() {
+  return __async(this, null, function* () {
+    var _a2;
+    yield import("./globals.cjs");
+    argv.ext = normalizeExt(argv.ext);
+    if (argv.cwd) import_index.$.cwd = argv.cwd;
+    if (argv.env) {
+      const envfile = import_index.path.resolve((_a2 = import_index.$.cwd) != null ? _a2 : process.cwd(), argv.env);
+      import_index.dotenv.config(envfile);
+      (0, import_index.resolveDefaults)();
+    }
+    if (argv.verbose) import_index.$.verbose = true;
+    if (argv.quiet) import_index.$.quiet = true;
+    if (argv.shell) import_index.$.shell = argv.shell;
+    if (argv.prefix) import_index.$.prefix = argv.prefix;
+    if (argv.postfix) import_index.$.postfix = argv.postfix;
+    if (argv.preferLocal) import_index.$.preferLocal = argv.preferLocal;
+    if (argv.version) {
+      console.log(import_index.VERSION);
+      return;
+    }
+    if (argv.help) {
+      printUsage();
+      return;
+    }
+    if (argv.repl) {
+      yield startRepl();
+      return;
+    }
+    const { script, scriptPath, tempPath } = yield readScript();
+    yield runScript(script, scriptPath, tempPath);
+  });
+}
+function runScript(script, scriptPath, tempPath) {
+  return __async(this, null, function* () {
+    let nmLink = "";
+    const rmTemp = () => {
+      import_index.fs.rmSync(tempPath, { force: true, recursive: true });
+      nmLink && import_index.fs.rmSync(nmLink, { force: true, recursive: true });
+    };
+    try {
+      if (tempPath) {
+        scriptPath = tempPath;
+        yield import_index.fs.writeFile(tempPath, script);
+      }
+      const cwd = import_index.path.dirname(scriptPath);
+      if (typeof argv.preferLocal === "string") {
+        nmLink = linkNodeModules(cwd, argv.preferLocal);
+      }
+      if (argv.install) {
+        yield (0, import_deps.installDeps)((0, import_deps.parseDeps)(script), cwd, argv.registry);
+      }
+      injectGlobalRequire(scriptPath);
+      process.once("exit", rmTemp);
+      yield import(import_node_url.default.pathToFileURL(scriptPath).toString());
+    } finally {
+      rmTemp();
+    }
+  });
+}
+function linkNodeModules(cwd, external) {
+  const nm = "node_modules";
+  const alias = import_index.path.resolve(cwd, nm);
+  const target = import_index.path.basename(external) === nm ? import_index.path.resolve(external) : import_index.path.resolve(external, nm);
+  if (import_index.fs.existsSync(alias) || !import_index.fs.existsSync(target)) return "";
+  import_index.fs.symlinkSync(target, alias, "junction");
+  return target;
+}
+function readScript() {
+  return __async(this, null, function* () {
+    const [firstArg] = argv._;
+    let script = "";
+    let scriptPath = "";
+    let tempPath = "";
+    let argSlice = 1;
+    if (argv.eval) {
+      argSlice = 0;
+      script = argv.eval;
+      tempPath = getFilepath(import_index.$.cwd, "zx", argv.ext);
+    } else if (!firstArg || firstArg === "-") {
+      script = yield readScriptFromStdin();
+      tempPath = getFilepath(import_index.$.cwd, "zx", argv.ext);
+      if (script.length === 0) {
+        printUsage();
+        process.exitCode = 1;
+        throw new Error("No script provided");
+      }
+    } else if (/^https?:/.test(firstArg)) {
+      const { name, ext: ext2 = argv.ext } = import_index.path.parse(new URL(firstArg).pathname);
+      script = yield readScriptFromHttp(firstArg);
+      tempPath = getFilepath(import_index.$.cwd, name, ext2);
+    } else {
+      script = yield import_index.fs.readFile(firstArg, "utf8");
+      scriptPath = firstArg.startsWith("file:") ? import_node_url.default.fileURLToPath(firstArg) : import_index.path.resolve(firstArg);
+    }
+    const { ext, base, dir } = import_index.path.parse(tempPath || scriptPath);
+    if (ext === "" || argv.ext && !EXT_RE.test(ext)) {
+      tempPath = getFilepath(dir, base);
+    }
+    if (ext === ".md") {
+      script = transformMarkdown(script);
+      tempPath = getFilepath(dir, base);
+    }
+    if (argSlice) (0, import_index.updateArgv)(argv._.slice(argSlice));
+    return { script, scriptPath, tempPath };
+  });
+}
+function readScriptFromStdin() {
+  return __async(this, null, function* () {
+    return !process.stdin.isTTY ? (0, import_index.stdin)() : "";
+  });
+}
+function readScriptFromHttp(remote) {
+  return __async(this, null, function* () {
+    const res = yield (0, import_index.fetch)(remote);
+    if (!res.ok) {
+      console.error(`Error: Can't get ${remote}`);
+      process.exit(1);
+    }
+    return res.text();
+  });
+}
+function injectGlobalRequire(origin) {
+  const __filename = import_index.path.resolve(origin);
+  const __dirname = import_index.path.dirname(__filename);
+  const require2 = (0, import_vendor.createRequire)(origin);
+  Object.assign(globalThis, { __filename, __dirname, require: require2 });
+}
+function isMain(metaurl = import_meta_url, scriptpath = process.argv[1]) {
+  if (metaurl.startsWith("file:")) {
+    const modulePath = import_node_url.default.fileURLToPath(metaurl).replace(/\.\w+$/, "");
+    const mainPath = import_index.fs.realpathSync(scriptpath).replace(/\.\w+$/, "");
+    return mainPath === modulePath;
+  }
+  return false;
+}
+function normalizeExt(ext) {
+  return ext ? import_index.path.parse(`foo.${ext}`).ext : ext;
+}
+function getFilepath(cwd = ".", name = "zx", _ext) {
+  const ext = _ext || argv.ext || EXT;
+  return [
+    name + ext,
+    name + "-" + (0, import_util2.randomId)() + ext
+  ].map((f) => import_index.path.resolve(process.cwd(), cwd, f)).find((f) => !import_index.fs.existsSync(f));
+}
+/* c8 ignore next 100 */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  argv,
+  injectGlobalRequire,
+  isMain,
+  main,
+  normalizeExt,
+  printUsage,
+  transformMarkdown
+});
\ No newline at end of file

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { transformMarkdown } from './md.js';
+import { type minimist } from './vendor.js';
+export declare function printUsage(): void;
+export declare const argv: minimist.ParsedArgs;
+export declare function main(): Promise<void>;
+export { transformMarkdown };
+export declare function injectGlobalRequire(origin: string): void;
+export declare function isMain(metaurl?: string, scriptpath?: string): boolean;
+export declare function normalizeExt(ext?: string): string | undefined;

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+import "./deno.js"
+import * as __module__ from "./cli.cjs"
+const {
+  argv,
+  injectGlobalRequire,
+  isMain,
+  main,
+  normalizeExt,
+  printUsage,
+  transformMarkdown
+} = globalThis.Deno ? globalThis.require("./cli.cjs") : __module__
+export {
+  argv,
+  injectGlobalRequire,
+  isMain,
+  main,
+  normalizeExt,
+  printUsage,
+  transformMarkdown
+}
+

@@ -0,0 +1,1053 @@
+"use strict";
+const {
+  __spreadValues,
+  __export,
+  __toESM,
+  __toCommonJS,
+  __async,
+  __await,
+  __asyncGenerator,
+  __yieldStar,
+  __forAwait
+} = require('./esblib.cjs');
+
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  $: () => $,
+  ProcessOutput: () => ProcessOutput,
+  ProcessPromise: () => ProcessPromise,
+  cd: () => cd,
+  chalk: () => import_vendor_core3.chalk,
+  defaults: () => defaults,
+  kill: () => kill,
+  log: () => log,
+  os: () => os,
+  path: () => import_node_path.default,
+  ps: () => import_vendor_core3.ps,
+  quote: () => import_util2.quote,
+  quotePowerShell: () => import_util2.quotePowerShell,
+  resolveDefaults: () => resolveDefaults,
+  syncProcessCwd: () => syncProcessCwd,
+  useBash: () => useBash,
+  usePowerShell: () => usePowerShell,
+  usePwsh: () => usePwsh,
+  which: () => import_vendor_core3.which,
+  within: () => within
+});
+module.exports = __toCommonJS(core_exports);
+var import_node_child_process = require("child_process");
+var import_node_async_hooks = require("async_hooks");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_util2 = require("util");
+var import_node_os = require("os");
+var import_node_events = require("events");
+
+// src/error.ts
+var EXIT_CODES = {
+  2: "Misuse of shell builtins",
+  126: "Invoked command cannot execute",
+  127: "Command not found",
+  128: "Invalid exit argument",
+  129: "Hangup",
+  130: "Interrupt",
+  131: "Quit and dump core",
+  132: "Illegal instruction",
+  133: "Trace/breakpoint trap",
+  134: "Process aborted",
+  135: 'Bus error: "access to undefined portion of memory object"',
+  136: 'Floating point exception: "erroneous arithmetic operation"',
+  137: "Kill (terminate immediately)",
+  138: "User-defined 1",
+  139: "Segmentation violation",
+  140: "User-defined 2",
+  141: "Write to pipe with no one reading",
+  142: "Signal raised by alarm",
+  143: "Termination (request to terminate)",
+  145: "Child process terminated, stopped (or continued*)",
+  146: "Continue if stopped",
+  147: "Stop executing temporarily",
+  148: "Terminal stop signal",
+  149: 'Background process attempting to read from tty ("in")',
+  150: 'Background process attempting to write to tty ("out")',
+  151: "Urgent data available on socket",
+  152: "CPU time limit exceeded",
+  153: "File size limit exceeded",
+  154: 'Signal raised by timer counting virtual time: "virtual timer expired"',
+  155: "Profiling timer expired",
+  157: "Pollable event",
+  159: "Bad syscall"
+};
+var ERRNO_CODES = {
+  0: "Success",
+  1: "Not super-user",
+  2: "No such file or directory",
+  3: "No such process",
+  4: "Interrupted system call",
+  5: "I/O error",
+  6: "No such device or address",
+  7: "Arg list too long",
+  8: "Exec format error",
+  9: "Bad file number",
+  10: "No children",
+  11: "No more processes",
+  12: "Not enough core",
+  13: "Permission denied",
+  14: "Bad address",
+  15: "Block device required",
+  16: "Mount device busy",
+  17: "File exists",
+  18: "Cross-device link",
+  19: "No such device",
+  20: "Not a directory",
+  21: "Is a directory",
+  22: "Invalid argument",
+  23: "Too many open files in system",
+  24: "Too many open files",
+  25: "Not a typewriter",
+  26: "Text file busy",
+  27: "File too large",
+  28: "No space left on device",
+  29: "Illegal seek",
+  30: "Read only file system",
+  31: "Too many links",
+  32: "Broken pipe",
+  33: "Math arg out of domain of func",
+  34: "Math result not representable",
+  35: "File locking deadlock error",
+  36: "File or path name too long",
+  37: "No record locks available",
+  38: "Function not implemented",
+  39: "Directory not empty",
+  40: "Too many symbolic links",
+  42: "No message of desired type",
+  43: "Identifier removed",
+  44: "Channel number out of range",
+  45: "Level 2 not synchronized",
+  46: "Level 3 halted",
+  47: "Level 3 reset",
+  48: "Link number out of range",
+  49: "Protocol driver not attached",
+  50: "No CSI structure available",
+  51: "Level 2 halted",
+  52: "Invalid exchange",
+  53: "Invalid request descriptor",
+  54: "Exchange full",
+  55: "No anode",
+  56: "Invalid request code",
+  57: "Invalid slot",
+  59: "Bad font file fmt",
+  60: "Device not a stream",
+  61: "No data (for no delay io)",
+  62: "Timer expired",
+  63: "Out of streams resources",
+  64: "Machine is not on the network",
+  65: "Package not installed",
+  66: "The object is remote",
+  67: "The link has been severed",
+  68: "Advertise error",
+  69: "Srmount error",
+  70: "Communication error on send",
+  71: "Protocol error",
+  72: "Multihop attempted",
+  73: "Cross mount point (not really error)",
+  74: "Trying to read unreadable message",
+  75: "Value too large for defined data type",
+  76: "Given log. name not unique",
+  77: "f.d. invalid for this operation",
+  78: "Remote address changed",
+  79: "Can   access a needed shared lib",
+  80: "Accessing a corrupted shared lib",
+  81: ".lib section in a.out corrupted",
+  82: "Attempting to link in too many libs",
+  83: "Attempting to exec a shared library",
+  84: "Illegal byte sequence",
+  86: "Streams pipe error",
+  87: "Too many users",
+  88: "Socket operation on non-socket",
+  89: "Destination address required",
+  90: "Message too long",
+  91: "Protocol wrong type for socket",
+  92: "Protocol not available",
+  93: "Unknown protocol",
+  94: "Socket type not supported",
+  95: "Not supported",
+  96: "Protocol family not supported",
+  97: "Address family not supported by protocol family",
+  98: "Address already in use",
+  99: "Address not available",
+  100: "Network interface is not configured",
+  101: "Network is unreachable",
+  102: "Connection reset by network",
+  103: "Connection aborted",
+  104: "Connection reset by peer",
+  105: "No buffer space available",
+  106: "Socket is already connected",
+  107: "Socket is not connected",
+  108: "Can't send after socket shutdown",
+  109: "Too many references",
+  110: "Connection timed out",
+  111: "Connection refused",
+  112: "Host is down",
+  113: "Host is unreachable",
+  114: "Socket already connected",
+  115: "Connection already in progress",
+  116: "Stale file handle",
+  122: "Quota exceeded",
+  123: "No medium (in tape drive)",
+  125: "Operation canceled",
+  130: "Previous owner died",
+  131: "State not recoverable"
+};
+function getErrnoMessage(errno) {
+  return ERRNO_CODES[-errno] || "Unknown error";
+}
+function getExitCodeInfo(exitCode) {
+  return EXIT_CODES[exitCode];
+}
+var formatExitMessage = (code, signal, stderr, from) => {
+  let message = `exit code: ${code}`;
+  if (code != 0 || signal != null) {
+    message = `${stderr || "\n"}    at ${from}`;
+    message += `
+    exit code: ${code}${getExitCodeInfo(code) ? " (" + getExitCodeInfo(code) + ")" : ""}`;
+    if (signal != null) {
+      message += `
+    signal: ${signal}`;
+    }
+  }
+  return message;
+};
+var formatErrorMessage = (err, from) => {
+  return `${err.message}
+    errno: ${err.errno} (${getErrnoMessage(err.errno)})
+    code: ${err.code}
+    at ${from}`;
+};
+function getCallerLocation(err = new Error("zx error")) {
+  return getCallerLocationFromString(err.stack);
+}
+function getCallerLocationFromString(stackString = "unknown") {
+  var _a;
+  return ((_a = stackString.split(/^\s*(at\s)?/m).filter((s) => s == null ? void 0 : s.includes(":"))[2]) == null ? void 0 : _a.trim()) || stackString;
+}
+
+// src/core.ts
+var import_vendor_core2 = require("./vendor-core.cjs");
+var import_util = require("./util.cjs");
+
+// src/log.ts
+var import_vendor_core = require("./vendor-core.cjs");
+var import_node_util = require("util");
+var formatters = {
+  cmd({ cmd }) {
+    return formatCmd(cmd);
+  },
+  stdout({ data }) {
+    return data;
+  },
+  stderr({ data }) {
+    return data;
+  },
+  custom({ data }) {
+    return data;
+  },
+  fetch(entry) {
+    const init = entry.init ? " " + (0, import_node_util.inspect)(entry.init) : "";
+    return `$ ${import_vendor_core.chalk.greenBright("fetch")} ${entry.url}${init}
+`;
+  },
+  cd(entry) {
+    return `$ ${import_vendor_core.chalk.greenBright("cd")} ${entry.dir}
+`;
+  },
+  retry(entry) {
+    const attempt = `Attempt: ${entry.attempt}${entry.total == Infinity ? "" : `/${entry.total}`}`;
+    const delay = entry.delay > 0 ? `; next in ${entry.delay}ms` : "";
+    return `${import_vendor_core.chalk.bgRed.white(" FAIL ")} ${attempt}${delay}
+`;
+  },
+  end() {
+    return "";
+  }
+};
+var log = function(entry) {
+  var _a;
+  if (!entry.verbose) return;
+  const stream = log.output || process.stderr;
+  const format = ((_a = log.formatters) == null ? void 0 : _a[entry.kind]) || formatters[entry.kind];
+  if (!format) return;
+  const data = format(entry);
+  stream.write(data);
+};
+var SYNTAX = "()[]{}<>;:+|&=";
+var CMD_BREAK = /* @__PURE__ */ new Set(["|", "&", ";", ">", "<"]);
+var SPACE_RE = /\s/;
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "case",
+  "esac",
+  "for",
+  "select",
+  "while",
+  "until",
+  "do",
+  "done",
+  "in",
+  "EOF"
+]);
+function formatCmd(cmd) {
+  if (cmd == void 0) return import_vendor_core.chalk.grey("undefined");
+  let q = "";
+  let out = "$ ";
+  let buf = "";
+  let mode = "";
+  let pos = 0;
+  const cap = () => {
+    const word = buf.trim();
+    if (word) {
+      pos++;
+      if (mode === "syntax") {
+        if (CMD_BREAK.has(word)) {
+          pos = 0;
+        }
+        out += import_vendor_core.chalk.red(buf);
+      } else if (mode === "quote" || mode === "dollar") {
+        out += import_vendor_core.chalk.yellowBright(buf);
+      } else if (RESERVED_WORDS.has(word)) {
+        out += import_vendor_core.chalk.cyanBright(buf);
+      } else if (pos === 1) {
+        out += import_vendor_core.chalk.greenBright(buf);
+        pos = Infinity;
+      } else {
+        out += buf;
+      }
+    } else {
+      out += buf;
+    }
+    mode = "";
+    buf = "";
+  };
+  for (const c of [...cmd]) {
+    if (!q) {
+      if (c === "$") {
+        cap();
+        mode = "dollar";
+        buf += c;
+        cap();
+      } else if (c === "'" || c === '"') {
+        cap();
+        mode = "quote";
+        q = c;
+        buf += c;
+      } else if (SPACE_RE.test(c)) {
+        cap();
+        buf += c;
+      } else if (SYNTAX.includes(c)) {
+        const isEnv = c === "=" && pos === 0;
+        isEnv && (pos = 1);
+        cap();
+        mode = "syntax";
+        buf += c;
+        cap();
+        isEnv && (pos = -1);
+      } else {
+        buf += c;
+      }
+    } else {
+      buf += c;
+      if (c === q) {
+        cap();
+        q = "";
+      }
+    }
+  }
+  cap();
+  return out.replaceAll("\n", import_vendor_core.chalk.reset("\n> ")) + "\n";
+}
+
+// src/core.ts
+var import_node_path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+var import_vendor_core3 = require("./vendor-core.cjs");
+var import_util2 = require("./util.cjs");
+var CWD = Symbol("processCwd");
+var SYNC = Symbol("syncExec");
+var EOL = Buffer.from(import_node_os.EOL);
+var BR_CC = "\n".charCodeAt(0);
+var SIGTERM = "SIGTERM";
+var ENV_PREFIX = "ZX_";
+var ENV_ALLOWED = /* @__PURE__ */ new Set([
+  "cwd",
+  "preferLocal",
+  "detached",
+  "verbose",
+  "quiet",
+  "timeout",
+  "timeoutSignal",
+  "killSignal",
+  "prefix",
+  "postfix",
+  "shell"
+]);
+var storage = new import_node_async_hooks.AsyncLocalStorage();
+function getStore() {
+  return storage.getStore() || defaults;
+}
+function within(callback) {
+  return storage.run(__spreadValues({}, getStore()), callback);
+}
+var defaults = resolveDefaults({
+  [CWD]: process.cwd(),
+  [SYNC]: false,
+  verbose: false,
+  env: process.env,
+  sync: false,
+  shell: true,
+  stdio: "pipe",
+  nothrow: false,
+  quiet: false,
+  prefix: "",
+  postfix: "",
+  detached: false,
+  preferLocal: false,
+  spawn: import_node_child_process.spawn,
+  spawnSync: import_node_child_process.spawnSync,
+  log,
+  kill,
+  killSignal: SIGTERM,
+  timeoutSignal: SIGTERM
+});
+var bound = [];
+var $ = new Proxy(
+  function(pieces, ...args) {
+    const snapshot = getStore();
+    if (!Array.isArray(pieces)) {
+      return function(...args2) {
+        const self = this;
+        return within(
+          () => Object.assign($, snapshot, pieces).apply(self, args2)
+        );
+      };
+    }
+    const from = getCallerLocation();
+    if (pieces.some((p) => p == void 0))
+      throw new Error(`Malformed command at ${from}`);
+    checkShell();
+    checkQuote();
+    const cmd = (0, import_vendor_core2.buildCmd)(
+      $.quote,
+      pieces,
+      args
+    );
+    const sync = snapshot[SYNC];
+    bound.push([cmd, from, snapshot]);
+    const process2 = new ProcessPromise(import_util.noop);
+    if (!process2.isHalted() || sync) process2.run();
+    return sync ? process2.output : process2;
+  },
+  {
+    set(_, key, value) {
+      const target = key in Function.prototype ? _ : getStore();
+      Reflect.set(target, key === "sync" ? SYNC : key, value);
+      return true;
+    },
+    get(_, key) {
+      if (key === "sync") return $({ sync: true });
+      const target = key in Function.prototype ? _ : getStore();
+      return Reflect.get(target, key);
+    }
+  }
+);
+var _ProcessPromise = class _ProcessPromise extends Promise {
+  constructor(executor) {
+    let resolve;
+    let reject;
+    super((...args) => {
+      ;
+      [resolve, reject] = args;
+      executor(...args);
+    });
+    this._stage = "initial";
+    this._id = (0, import_util.randomId)();
+    this._command = "";
+    this._from = "";
+    this._snapshot = getStore();
+    this._piped = false;
+    this._ee = new import_node_events.EventEmitter();
+    this._stdin = new import_vendor_core2.VoidStream();
+    this._zurk = null;
+    this._output = null;
+    this._reject = import_util.noop;
+    this._resolve = import_util.noop;
+    // Stream-like API
+    this.writable = true;
+    if (bound.length) {
+      const [cmd, from, snapshot] = bound.pop();
+      this._command = cmd;
+      this._from = from;
+      this._resolve = resolve;
+      this._reject = (v) => {
+        reject(v);
+        if (snapshot[SYNC]) throw v;
+      };
+      this._snapshot = __spreadValues({ ac: new AbortController() }, snapshot);
+      if (this._snapshot.halt) this._stage = "halted";
+    } else _ProcessPromise.disarm(this);
+  }
+  run() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (this.isRunning() || this.isSettled()) return this;
+    this._stage = "running";
+    (_a = this._pipedFrom) == null ? void 0 : _a.run();
+    const self = this;
+    const $2 = self._snapshot;
+    const id = self.id;
+    const sync = $2[SYNC];
+    const timeout = (_b = self._timeout) != null ? _b : $2.timeout;
+    const timeoutSignal = (_c = self._timeoutSignal) != null ? _c : $2.timeoutSignal;
+    if ($2.preferLocal) {
+      const dirs = $2.preferLocal === true ? [$2.cwd, $2[CWD]] : [$2.preferLocal].flat();
+      $2.env = (0, import_util.preferLocalBin)($2.env, ...dirs);
+    }
+    $2.log({
+      kind: "cmd",
+      cmd: self.cmd,
+      verbose: self.isVerbose(),
+      id
+    });
+    this._zurk = (0, import_vendor_core2.exec)({
+      sync,
+      id,
+      cmd: self.fullCmd,
+      cwd: (_d = $2.cwd) != null ? _d : $2[CWD],
+      input: (_f = (_e = $2.input) == null ? void 0 : _e.stdout) != null ? _f : $2.input,
+      ac: $2.ac,
+      signal: $2.signal,
+      shell: (0, import_util.isString)($2.shell) ? $2.shell : true,
+      env: $2.env,
+      spawn: $2.spawn,
+      spawnSync: $2.spawnSync,
+      store: $2.store,
+      stdin: self._stdin,
+      stdio: (_g = self._stdio) != null ? _g : $2.stdio,
+      detached: $2.detached,
+      ee: self._ee,
+      run: (cb) => cb(),
+      on: {
+        start: () => {
+          !sync && timeout && self.timeout(timeout, timeoutSignal);
+        },
+        stdout: (data) => {
+          if (self._piped) return;
+          $2.log({ kind: "stdout", data, verbose: self.isVerbose(), id });
+        },
+        stderr: (data) => {
+          $2.log({ kind: "stderr", data, verbose: !self.isQuiet(), id });
+        },
+        end: (data, c) => {
+          const { error, status, signal, duration, ctx: { store } } = data;
+          const { stdout, stderr } = store;
+          const output = self._output = new ProcessOutput({
+            code: status,
+            signal,
+            error,
+            duration,
+            store,
+            from: self._from
+          });
+          $2.log({ kind: "end", signal, exitCode: status, duration, error, verbose: self.isVerbose(), id });
+          if (stdout.length && (0, import_util.getLast)((0, import_util.getLast)(stdout)) !== BR_CC) c.on.stdout(EOL, c);
+          if (stderr.length && (0, import_util.getLast)((0, import_util.getLast)(stderr)) !== BR_CC) c.on.stderr(EOL, c);
+          if (!output.ok && !self.isNothrow()) {
+            self._stage = "rejected";
+            self._reject(output);
+          } else {
+            self._stage = "fulfilled";
+            self._resolve(output);
+          }
+        }
+      }
+    });
+    return this;
+  }
+  _pipe(source, dest, ...args) {
+    if ((0, import_util.isStringLiteral)(dest, ...args))
+      return this.pipe[source](
+        $({
+          halt: true,
+          ac: this._snapshot.ac,
+          signal: this._snapshot.signal
+        })(dest, ...args)
+      );
+    this._piped = true;
+    const ee = this._ee;
+    const from = new import_vendor_core2.VoidStream();
+    const fill = () => {
+      for (const chunk of this._zurk.store[source]) from.write(chunk);
+      return true;
+    };
+    const fillEnd = () => this.isSettled() && fill() && from.end();
+    if (!this.isSettled()) {
+      const onData = (chunk) => from.write(chunk);
+      ee.once(source, () => {
+        fill();
+        ee.on(source, onData);
+      }).once("end", () => {
+        ee.removeListener(source, onData);
+        from.end();
+      });
+    }
+    if ((0, import_util.isString)(dest)) dest = import_node_fs.default.createWriteStream(dest);
+    if (dest instanceof _ProcessPromise) {
+      dest._pipedFrom = this;
+      if (dest.isHalted() && this.isHalted()) {
+        ee.once("start", () => from.pipe(dest.run()._stdin));
+      } else {
+        this.catch((e) => dest.isNothrow() ? import_util.noop : dest._reject(e));
+        from.pipe(dest.run()._stdin);
+      }
+      fillEnd();
+      return dest;
+    }
+    from.once("end", () => dest.emit("end-piped-from")).pipe(dest);
+    fillEnd();
+    return promisifyStream(dest, this);
+  }
+  abort(reason) {
+    var _a, _b;
+    if (this.signal !== ((_a = this._snapshot.ac) == null ? void 0 : _a.signal))
+      throw new Error("The signal is controlled by another process.");
+    if (!this.child)
+      throw new Error("Trying to abort a process without creating one.");
+    (_b = this._zurk) == null ? void 0 : _b.ac.abort(reason);
+  }
+  kill(signal = $.killSignal) {
+    if (!this.child)
+      throw new Error("Trying to kill a process without creating one.");
+    if (!this.child.pid) throw new Error("The process pid is undefined.");
+    return $.kill(this.child.pid, signal);
+  }
+  /**
+   *  @deprecated Use $({halt: true})`cmd` instead.
+   */
+  halt() {
+    return this;
+  }
+  // Getters
+  get id() {
+    return this._id;
+  }
+  get pid() {
+    var _a;
+    return (_a = this.child) == null ? void 0 : _a.pid;
+  }
+  get cmd() {
+    return this._command;
+  }
+  get fullCmd() {
+    return this._snapshot.prefix + this.cmd + this._snapshot.postfix;
+  }
+  get child() {
+    var _a;
+    return (_a = this._zurk) == null ? void 0 : _a.child;
+  }
+  get stdin() {
+    var _a;
+    return (_a = this.child) == null ? void 0 : _a.stdin;
+  }
+  get stdout() {
+    var _a;
+    return (_a = this.child) == null ? void 0 : _a.stdout;
+  }
+  get stderr() {
+    var _a;
+    return (_a = this.child) == null ? void 0 : _a.stderr;
+  }
+  get exitCode() {
+    return this.then(
+      (p) => p.exitCode,
+      (p) => p.exitCode
+    );
+  }
+  get signal() {
+    var _a;
+    return this._snapshot.signal || ((_a = this._snapshot.ac) == null ? void 0 : _a.signal);
+  }
+  get output() {
+    return this._output;
+  }
+  get stage() {
+    return this._stage;
+  }
+  get [Symbol.toStringTag]() {
+    return "ProcessPromise";
+  }
+  [Symbol.toPrimitive]() {
+    return this.toString();
+  }
+  // Configurators
+  stdio(stdin, stdout = "pipe", stderr = "pipe") {
+    this._stdio = [stdin, stdout, stderr];
+    return this;
+  }
+  nothrow(v = true) {
+    this._nothrow = v;
+    return this;
+  }
+  quiet(v = true) {
+    this._quiet = v;
+    return this;
+  }
+  verbose(v = true) {
+    this._verbose = v;
+    return this;
+  }
+  timeout(d, signal = this._timeoutSignal || $.timeoutSignal) {
+    if (this.isSettled()) return this;
+    this._timeout = (0, import_util.parseDuration)(d);
+    this._timeoutSignal = signal;
+    if (this._timeoutId) clearTimeout(this._timeoutId);
+    if (this._timeout && this.isRunning()) {
+      this._timeoutId = setTimeout(
+        () => this.kill(this._timeoutSignal),
+        this._timeout
+      );
+      this.finally(() => clearTimeout(this._timeoutId)).catch(import_util.noop);
+    }
+    return this;
+  }
+  // Output formatters
+  json() {
+    return this.then((p) => p.json());
+  }
+  text(encoding) {
+    return this.then((p) => p.text(encoding));
+  }
+  lines() {
+    return this.then((p) => p.lines());
+  }
+  buffer() {
+    return this.then((p) => p.buffer());
+  }
+  blob(type) {
+    return this.then((p) => p.blob(type));
+  }
+  // Status checkers
+  isQuiet() {
+    var _a;
+    return (_a = this._quiet) != null ? _a : this._snapshot.quiet;
+  }
+  isVerbose() {
+    var _a;
+    return ((_a = this._verbose) != null ? _a : this._snapshot.verbose) && !this.isQuiet();
+  }
+  isNothrow() {
+    var _a;
+    return (_a = this._nothrow) != null ? _a : this._snapshot.nothrow;
+  }
+  isHalted() {
+    return this.stage === "halted";
+  }
+  isSettled() {
+    return !!this.output;
+  }
+  isRunning() {
+    return this.stage === "running";
+  }
+  // Promise API
+  then(onfulfilled, onrejected) {
+    return super.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return super.catch(onrejected);
+  }
+  // Async iterator API
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, null, function* () {
+      const memo = [];
+      for (const chunk of this._zurk.store.stdout) {
+        yield* __yieldStar((0, import_util.getLines)(chunk, memo));
+      }
+      try {
+        for (var iter = __forAwait(this.stdout[Symbol.asyncIterator] ? this.stdout : import_vendor_core2.VoidStream.from(this.stdout)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          yield* __yieldStar((0, import_util.getLines)(chunk, memo));
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      if (memo[0]) yield memo[0];
+      if ((yield new __await(this.exitCode)) !== 0) throw this._output;
+    });
+  }
+  emit(event, ...args) {
+    return this;
+  }
+  on(event, cb) {
+    this._stdin.on(event, cb);
+    return this;
+  }
+  once(event, cb) {
+    this._stdin.once(event, cb);
+    return this;
+  }
+  write(data, encoding, cb) {
+    this._stdin.write(data, encoding, cb);
+    return this;
+  }
+  end(chunk, cb) {
+    this._stdin.end(chunk, cb);
+    return this;
+  }
+  removeListener(event, cb) {
+    this._stdin.removeListener(event, cb);
+    return this;
+  }
+  // prettier-ignore
+  static disarm(p, toggle = true) {
+    Object.getOwnPropertyNames(_ProcessPromise.prototype).forEach((k) => {
+      if (k in Promise.prototype) return;
+      if (!toggle) {
+        Reflect.deleteProperty(p, k);
+        return;
+      }
+      Object.defineProperty(p, k, { configurable: true, get() {
+        throw new Error("Inappropriate usage. Apply $ instead of direct instantiation.");
+      } });
+    });
+  }
+};
+Object.defineProperty(_ProcessPromise.prototype, "pipe", { get() {
+  const self = this;
+  const getPipeMethod = (kind) => function(dest, ...args) {
+    return self._pipe.call(self, kind, dest, ...args);
+  };
+  const stdout = getPipeMethod("stdout");
+  const stderr = getPipeMethod("stderr");
+  const stdall = getPipeMethod("stdall");
+  return Object.assign(stdout, { stderr, stdout, stdall });
+} });
+var ProcessPromise = _ProcessPromise;
+var _ProcessOutput = class _ProcessOutput extends Error {
+  // prettier-ignore
+  constructor(code, signal = null, stdout = "", stderr = "", stdall = "", message = "", duration = 0, error = null, from = "", store = { stdout: [stdout], stderr: [stderr], stdall: [stdall] }) {
+    super(message);
+    const dto = this._dto = code !== null && typeof code === "object" ? code : { code, signal, duration, error, from, store };
+    Object.defineProperties(this, {
+      cause: { value: dto.error, enumerable: false, writable: true, configurable: true },
+      stdout: { get: (0, import_util.once)(() => (0, import_util.bufArrJoin)(dto.store.stdout)) },
+      stderr: { get: (0, import_util.once)(() => (0, import_util.bufArrJoin)(dto.store.stderr)) },
+      stdall: { get: (0, import_util.once)(() => (0, import_util.bufArrJoin)(dto.store.stdall)) },
+      message: {
+        get: (0, import_util.once)(
+          () => message || dto.error ? _ProcessOutput.getErrorMessage(dto.error, dto.from) : _ProcessOutput.getExitMessage(dto.code, dto.signal, this.stderr, dto.from)
+        )
+      }
+    });
+  }
+  get exitCode() {
+    return this._dto.code;
+  }
+  get signal() {
+    return this._dto.signal;
+  }
+  get duration() {
+    return this._dto.duration;
+  }
+  get [Symbol.toStringTag]() {
+    return "ProcessOutput";
+  }
+  get ok() {
+    return !this._dto.error && this.exitCode === 0;
+  }
+  [Symbol.toPrimitive]() {
+    return this.valueOf();
+  }
+  toString() {
+    return this.stdall;
+  }
+  json() {
+    return JSON.parse(this.stdall);
+  }
+  buffer() {
+    return Buffer.from(this.stdall);
+  }
+  blob(type = "text/plain") {
+    if (!globalThis.Blob)
+      throw new Error(
+        "Blob is not supported in this environment. Provide a polyfill"
+      );
+    return new Blob([this.buffer()], { type });
+  }
+  text(encoding = "utf8") {
+    return encoding === "utf8" ? this.toString() : this.buffer().toString(encoding);
+  }
+  lines() {
+    return [...this];
+  }
+  valueOf() {
+    return this.stdall.trim();
+  }
+  *[Symbol.iterator]() {
+    const memo = [];
+    for (const chunk of this._dto.store.stdall) {
+      yield* __yieldStar((0, import_util.getLines)(chunk, memo));
+    }
+    if (memo[0]) yield memo[0];
+  }
+  [import_node_util2.inspect.custom]() {
+    const stringify = (s, c) => s.length === 0 ? "''" : c((0, import_node_util2.inspect)(s));
+    return `ProcessOutput {
+  stdout: ${stringify(this.stdout, import_vendor_core2.chalk.green)},
+  stderr: ${stringify(this.stderr, import_vendor_core2.chalk.red)},
+  signal: ${(0, import_node_util2.inspect)(this.signal)},
+  exitCode: ${(this.exitCode === 0 ? import_vendor_core2.chalk.green : import_vendor_core2.chalk.red)(this.exitCode)}${getExitCodeInfo(this.exitCode) ? import_vendor_core2.chalk.grey(" (" + getExitCodeInfo(this.exitCode) + ")") : ""},
+  duration: ${this.duration}
+}`;
+  }
+};
+_ProcessOutput.getExitMessage = formatExitMessage;
+_ProcessOutput.getErrorMessage = formatErrorMessage;
+var ProcessOutput = _ProcessOutput;
+function usePowerShell() {
+  $.shell = import_vendor_core2.which.sync("powershell.exe");
+  $.prefix = "";
+  $.postfix = "; exit $LastExitCode";
+  $.quote = import_util.quotePowerShell;
+}
+function usePwsh() {
+  $.shell = import_vendor_core2.which.sync("pwsh");
+  $.prefix = "";
+  $.postfix = "; exit $LastExitCode";
+  $.quote = import_util.quotePowerShell;
+}
+function useBash() {
+  $.shell = import_vendor_core2.which.sync("bash");
+  $.prefix = "set -euo pipefail;";
+  $.postfix = "";
+  $.quote = import_util.quote;
+}
+try {
+  useBash();
+} catch (err) {
+}
+function checkShell() {
+  if (!$.shell)
+    throw new Error(`No shell is available: https://google.github.io/zx/shell`);
+}
+function checkQuote() {
+  if (!$.quote)
+    throw new Error(
+      "No quote function is defined: https://google.github.io/zx/quotes"
+    );
+}
+var cwdSyncHook;
+function syncProcessCwd(flag = true) {
+  cwdSyncHook = cwdSyncHook || (0, import_node_async_hooks.createHook)({
+    init: syncCwd,
+    before: syncCwd,
+    promiseResolve: syncCwd,
+    after: syncCwd,
+    destroy: syncCwd
+  });
+  if (flag) cwdSyncHook.enable();
+  else cwdSyncHook.disable();
+}
+function syncCwd() {
+  if ($[CWD] != process.cwd()) process.chdir($[CWD]);
+}
+function cd(dir) {
+  if (dir instanceof ProcessOutput) {
+    dir = dir.toString().trim();
+  }
+  $.log({ kind: "cd", dir, verbose: !$.quiet && $.verbose });
+  process.chdir(dir);
+  $[CWD] = process.cwd();
+}
+function kill(_0) {
+  return __async(this, arguments, function* (pid, signal = $.killSignal) {
+    const children = yield import_vendor_core2.ps.tree({ pid, recursive: true });
+    for (const p of children) {
+      try {
+        process.kill(+p.pid, signal);
+      } catch (e) {
+      }
+    }
+    try {
+      process.kill(-pid, signal);
+    } catch (e) {
+      try {
+        process.kill(+pid, signal);
+      } catch (e2) {
+      }
+    }
+  });
+}
+var promisifyStream = (stream, from) => (0, import_util.proxyOverride)(stream, {
+  then(res = import_util.noop, rej = import_util.noop) {
+    return new Promise(
+      (_res, _rej) => stream.once("error", (e) => _rej(rej(e))).once(
+        "finish",
+        () => _res(res((0, import_util.proxyOverride)(stream, from._output)))
+      ).once(
+        "end-piped-from",
+        () => _res(res((0, import_util.proxyOverride)(stream, from._output)))
+      )
+    );
+  },
+  run() {
+    return from.run();
+  },
+  _pipedFrom: from,
+  pipe(...args) {
+    const piped = stream.pipe.apply(stream, args);
+    return piped instanceof ProcessPromise ? piped : promisifyStream(piped, from);
+  }
+});
+function resolveDefaults(defs = defaults, prefix = ENV_PREFIX, env = process.env, allowed = ENV_ALLOWED) {
+  return Object.entries(env).reduce((m, [k, v]) => {
+    if (v && k.startsWith(prefix)) {
+      const _k = (0, import_util.toCamelCase)(k.slice(prefix.length));
+      const _v = (0, import_util.parseBool)(v);
+      if (allowed.has(_k)) m[_k] = _v;
+    }
+    return m;
+  }, defs);
+}
+/* c8 ignore next 100 */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $,
+  ProcessOutput,
+  ProcessPromise,
+  cd,
+  chalk,
+  defaults,
+  kill,
+  log,
+  os,
+  path,
+  ps,
+  quote,
+  quotePowerShell,
+  resolveDefaults,
+  syncProcessCwd,
+  useBash,
+  usePowerShell,
+  usePwsh,
+  which,
+  within
+});
\ No newline at end of file

@@ -0,0 +1,183 @@
+/// <reference types="node" />
+/// <reference types="fs-extra" />
+
+import { type ChildProcess, type IOType, type StdioOptions, spawn, spawnSync } from 'node:child_process';
+import { type Encoding } from 'node:crypto';
+import { type Readable, type Writable } from 'node:stream';
+import { inspect } from 'node:util';
+import { type TSpawnStore } from './vendor-core.js';
+import { type Duration, quote } from './util.js';
+import { log } from './log.js';
+export { default as path } from 'node:path';
+export * as os from 'node:os';
+export { log, type LogEntry } from './log.js';
+export { chalk, which, ps } from './vendor-core.js';
+export { quote, quotePowerShell } from './util.js';
+declare const CWD: unique symbol;
+declare const SYNC: unique symbol;
+export declare function within<R>(callback: () => R): R;
+export interface Options {
+    [CWD]: string;
+    [SYNC]: boolean;
+    cwd?: string;
+    ac?: AbortController;
+    signal?: AbortSignal;
+    input?: string | Buffer | Readable | ProcessOutput | ProcessPromise;
+    timeout?: Duration;
+    timeoutSignal?: NodeJS.Signals;
+    stdio: StdioOptions;
+    verbose: boolean;
+    sync: boolean;
+    env: NodeJS.ProcessEnv;
+    shell: string | true;
+    nothrow: boolean;
+    prefix: string;
+    postfix: string;
+    quote?: typeof quote;
+    quiet: boolean;
+    detached: boolean;
+    preferLocal: boolean | string | string[];
+    spawn: typeof spawn;
+    spawnSync: typeof spawnSync;
+    store?: TSpawnStore;
+    log: typeof log;
+    kill: typeof kill;
+    killSignal?: NodeJS.Signals;
+    halt?: boolean;
+}
+export declare const defaults: Options;
+export interface Shell<S = false, R = S extends true ? ProcessOutput : ProcessPromise> {
+    (pieces: TemplateStringsArray, ...args: any[]): R;
+    <O extends Partial<Options> = Partial<Options>, R = O extends {
+        sync: true;
+    } ? Shell<true> : Shell>(opts: O): R;
+    sync: {
+        (pieces: TemplateStringsArray, ...args: any[]): ProcessOutput;
+        (opts: Partial<Omit<Options, 'sync'>>): Shell<true>;
+    };
+}
+export declare const $: Shell & Options;
+type ProcessStage = 'initial' | 'halted' | 'running' | 'fulfilled' | 'rejected';
+type Resolve = (out: ProcessOutput) => void;
+type PipeMethod = {
+    (dest: TemplateStringsArray, ...args: any[]): ProcessPromise;
+    <D extends Writable>(dest: D): D & PromiseLike<ProcessOutput & D>;
+    <D extends ProcessPromise>(dest: D): D;
+};
+export declare class ProcessPromise extends Promise<ProcessOutput> {
+    private _stage;
+    private _id;
+    private _command;
+    private _from;
+    private _snapshot;
+    private _stdio?;
+    private _nothrow?;
+    private _quiet?;
+    private _verbose?;
+    private _timeout?;
+    private _timeoutSignal?;
+    private _timeoutId?;
+    private _piped;
+    private _pipedFrom?;
+    private _ee;
+    private _stdin;
+    private _zurk;
+    private _output;
+    private _reject;
+    private _resolve;
+    constructor(executor: (resolve: Resolve, reject: Resolve) => void);
+    run(): ProcessPromise;
+    pipe: PipeMethod & {
+        [key in keyof TSpawnStore]: PipeMethod;
+    };
+    private _pipe;
+    abort(reason?: string): void;
+    kill(signal?: NodeJS.Signals | undefined): Promise<void>;
+    /**
+     *  @deprecated Use $({halt: true})`cmd` instead.
+     */
+    halt(): this;
+    get id(): string;
+    get pid(): number | undefined;
+    get cmd(): string;
+    get fullCmd(): string;
+    get child(): ChildProcess | undefined;
+    get stdin(): Writable;
+    get stdout(): Readable;
+    get stderr(): Readable;
+    get exitCode(): Promise<number | null>;
+    get signal(): AbortSignal | undefined;
+    get output(): ProcessOutput | null;
+    get stage(): ProcessStage;
+    get [Symbol.toStringTag](): string;
+    [Symbol.toPrimitive](): string;
+    stdio(stdin: IOType, stdout?: IOType, stderr?: IOType): ProcessPromise;
+    nothrow(v?: boolean): ProcessPromise;
+    quiet(v?: boolean): ProcessPromise;
+    verbose(v?: boolean): ProcessPromise;
+    timeout(d: Duration, signal?: NodeJS.Signals | undefined): ProcessPromise;
+    json<T = any>(): Promise<T>;
+    text(encoding?: Encoding): Promise<string>;
+    lines(): Promise<string[]>;
+    buffer(): Promise<Buffer>;
+    blob(type?: string): Promise<Blob>;
+    isQuiet(): boolean;
+    isVerbose(): boolean;
+    isNothrow(): boolean;
+    isHalted(): boolean;
+    private isSettled;
+    private isRunning;
+    then<R = ProcessOutput, E = ProcessOutput>(onfulfilled?: ((value: ProcessOutput) => PromiseLike<R> | R) | undefined | null, onrejected?: ((reason: ProcessOutput) => PromiseLike<E> | E) | undefined | null): Promise<R | E>;
+    catch<T = ProcessOutput>(onrejected?: ((reason: ProcessOutput) => PromiseLike<T> | T) | undefined | null): Promise<ProcessOutput | T>;
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+    private writable;
+    private emit;
+    private on;
+    private once;
+    private write;
+    private end;
+    private removeListener;
+    private static disarm;
+}
+type ProcessDto = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    duration: number;
+    error: any;
+    from: string;
+    store: TSpawnStore;
+};
+export declare class ProcessOutput extends Error {
+    private readonly _dto;
+    cause: Error | null;
+    message: string;
+    stdout: string;
+    stderr: string;
+    stdall: string;
+    constructor(dto: ProcessDto);
+    constructor(code: number | null, signal: NodeJS.Signals | null, stdout: string, stderr: string, stdall: string, message: string, duration?: number);
+    get exitCode(): number | null;
+    get signal(): NodeJS.Signals | null;
+    get duration(): number;
+    get [Symbol.toStringTag](): string;
+    get ok(): boolean;
+    [Symbol.toPrimitive](): string;
+    toString(): string;
+    json<T = any>(): T;
+    buffer(): Buffer;
+    blob(type?: string): Blob;
+    text(encoding?: Encoding): string;
+    lines(): string[];
+    valueOf(): string;
+    [Symbol.iterator](): Iterator<string>;
+    static getExitMessage: (code: number | null, signal: NodeJS.Signals | null, stderr: string, from: string) => string;
+    static getErrorMessage: (err: NodeJS.ErrnoException, from: string) => string;
+    [inspect.custom](): string;
+}
+export declare function usePowerShell(): void;
+export declare function usePwsh(): void;
+export declare function useBash(): void;
+export declare function syncProcessCwd(flag?: boolean): void;
+export declare function cd(dir: string | ProcessOutput): void;
+export declare function kill(pid: number, signal?: NodeJS.Signals | undefined): Promise<void>;
+export declare function resolveDefaults(defs?: Options, prefix?: string, env?: NodeJS.ProcessEnv, allowed?: Set<string>): Options;

@@ -0,0 +1,48 @@
+"use strict";
+import "./deno.js"
+import * as __module__ from "./core.cjs"
+const {
+  $,
+  ProcessOutput,
+  ProcessPromise,
+  cd,
+  chalk,
+  defaults,
+  kill,
+  log,
+  os,
+  path,
+  ps,
+  quote,
+  quotePowerShell,
+  resolveDefaults,
+  syncProcessCwd,
+  useBash,
+  usePowerShell,
+  usePwsh,
+  which,
+  within
+} = globalThis.Deno ? globalThis.require("./core.cjs") : __module__
+export {
+  $,
+  ProcessOutput,
+  ProcessPromise,
+  cd,
+  chalk,
+  defaults,
+  kill,
+  log,
+  os,
+  path,
+  ps,
+  quote,
+  quotePowerShell,
+  resolveDefaults,
+  syncProcessCwd,
+  useBash,
+  usePowerShell,
+  usePwsh,
+  which,
+  within
+}
+

@@ -0,0 +1,16 @@
+import { createRequire } from 'node:module'
+import * as process from 'node:process'
+
+// prettier-ignore
+if (globalThis.Deno) {
+  globalThis.require = createRequire(import.meta.url)
+  globalThis.__filename = new URL(import.meta.url).pathname
+  globalThis.__dirname = new URL('.', import.meta.url).pathname
+  globalThis.module = new Proxy({}, { set() { return true } })
+
+  const p = globalThis.process = globalThis.process || process
+  p.version || (p.version = 'v18.0.0')
+  p.version || (p.version = { node: '18.0.0' })
+  p.env || (p.env = globalThis.Deno.env.toObject())
+  p.argv || (p.argv = [globalThis.Deno.execPath(), globalThis.Deno.mainModule.replace('file://', ''), ...globalThis.Deno.args])
+}

@@ -0,0 +1,123 @@
+"use strict";
+const {
+  __export,
+  __toCommonJS,
+  __async
+} = require('./esblib.cjs');
+
+
+// src/deps.ts
+var deps_exports = {};
+__export(deps_exports, {
+  installDeps: () => installDeps,
+  parseDeps: () => parseDeps
+});
+module.exports = __toCommonJS(deps_exports);
+var import_core = require("./core.cjs");
+var import_goods = require("./goods.cjs");
+var import_vendor = require("./vendor.cjs");
+function installDeps(dependencies, prefix, registry) {
+  return __async(this, null, function* () {
+    const prefixFlag = prefix ? `--prefix=${prefix}` : "";
+    const registryFlag = registry ? `--registry=${registry}` : "";
+    const packages = Object.entries(dependencies).map(
+      ([name, version]) => `${name}@${version}`
+    );
+    if (packages.length === 0) {
+      return;
+    }
+    yield (0, import_goods.spinner)(
+      `npm i ${packages.join(" ")}`,
+      () => import_core.$`npm install --no-save --no-audit --no-fund ${registryFlag} ${prefixFlag} ${packages}`.nothrow()
+    );
+  });
+}
+var builtins = /* @__PURE__ */ new Set([
+  "_http_agent",
+  "_http_client",
+  "_http_common",
+  "_http_incoming",
+  "_http_outgoing",
+  "_http_server",
+  "_stream_duplex",
+  "_stream_passthrough",
+  "_stream_readable",
+  "_stream_transform",
+  "_stream_wrap",
+  "_stream_writable",
+  "_tls_common",
+  "_tls_wrap",
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib"
+]);
+var nameRe = new RegExp("^(?<name>(@[a-z\\d-~][\\w-.~]*\\/)?[a-z\\d-~][\\w-.~]*)\\/?.*$", "i");
+var versionRe = new RegExp("^@(?<version>[~^]?(v?[\\dx*]+([-.][\\d*a-z-]+)*))", "i");
+function parseDeps(content) {
+  return (0, import_vendor.depseek)(content + "\n", { comments: true }).reduce((m, { type, value }, i, list) => {
+    if (type === "dep") {
+      const meta = list[i + 1];
+      const name = parsePackageName(value);
+      const version = (meta == null ? void 0 : meta.type) === "comment" && parseVersion(meta == null ? void 0 : meta.value.trim()) || "latest";
+      if (name) m[name] = version;
+    }
+    return m;
+  }, {});
+}
+function parsePackageName(path) {
+  var _a, _b;
+  if (!path) return;
+  const name = (_b = (_a = nameRe.exec(path)) == null ? void 0 : _a.groups) == null ? void 0 : _b.name;
+  if (name && !builtins.has(name)) {
+    return name;
+  }
+}
+function parseVersion(line) {
+  var _a, _b;
+  return ((_b = (_a = versionRe.exec(line)) == null ? void 0 : _a.groups) == null ? void 0 : _b.version) || "latest";
+}
+/* c8 ignore next 100 */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installDeps,
+  parseDeps
+});
\ No newline at end of file