shadcn-svelte 0.8.1 → 0.8.3

package/dist/index.js

@@ -19,7 +19,7 @@ import path8 from "path";
 import chalk2 from "chalk";
 import { execa as execa2 } from "execa";
 
-// node_modules/.pnpm/tsconfck@2.1.2_typescript@5.3.3/node_modules/tsconfck/dist/index.js
+// ../../node_modules/.pnpm/tsconfck@2.1.2_typescript@5.3.3/node_modules/tsconfck/dist/index.js
 import path2 from "path";
 import path3 from "path";
 import { promises as fs2 } from "fs";
@@ -195,13 +195,13 @@ async function findNative(filename) {
   }
   return tsconfigFile;
 }
-async function parseNative(filename, options) {
-  const cache = options == null ? void 0 : options.cache;
+async function parseNative(filename, options2) {
+  const cache = options2 == null ? void 0 : options2.cache;
   if (cache == null ? void 0 : cache.has(filename)) {
     return cache.get(filename);
   }
   let tsconfigFile;
-  if (options == null ? void 0 : options.resolveWithEmptyIfConfigNotFound) {
+  if (options2 == null ? void 0 : options2.resolveWithEmptyIfConfigNotFound) {
     try {
       tsconfigFile = await resolveTSConfig(filename);
       if (!tsconfigFile) {
@@ -227,16 +227,16 @@ async function parseNative(filename, options) {
     result = cache.get(tsconfigFile);
   } else {
     const ts = await loadTS();
-    result = await parseFile2(tsconfigFile, ts, options);
-    await parseReferences2(result, ts, options);
+    result = await parseFile2(tsconfigFile, ts, options2);
+    await parseReferences2(result, ts, options2);
     cache == null ? void 0 : cache.set(tsconfigFile, result);
   }
   result = resolveSolutionTSConfig(filename, result);
   cache == null ? void 0 : cache.set(filename, result);
   return result;
 }
-async function parseFile2(tsconfigFile, ts, options) {
-  const cache = options == null ? void 0 : options.cache;
+async function parseFile2(tsconfigFile, ts, options2) {
+  const cache = options2 == null ? void 0 : options2.cache;
   if (cache == null ? void 0 : cache.has(tsconfigFile)) {
     return cache.get(tsconfigFile);
   }
@@ -252,7 +252,7 @@ async function parseFile2(tsconfigFile, ts, options) {
     fileExists: sys.fileExists,
     readFile: sys.readFile
   };
-  if (options == null ? void 0 : options.ignoreSourceFiles) {
+  if (options2 == null ? void 0 : options2.ignoreSourceFiles) {
     config.files = [];
     config.include = [];
   }
@@ -272,13 +272,13 @@ async function parseFile2(tsconfigFile, ts, options) {
   cache == null ? void 0 : cache.set(tsconfigFile, result);
   return result;
 }
-async function parseReferences2(result, ts, options) {
+async function parseReferences2(result, ts, options2) {
   if (!result.tsconfig.references) {
     return;
   }
   const referencedFiles = resolveReferencedTSConfigFiles(result);
   result.referenced = await Promise.all(
-    referencedFiles.map((file) => parseFile2(file, ts, options))
+    referencedFiles.map((file) => parseFile2(file, ts, options2))
   );
 }
 function checkErrors(nativeResult, tsconfigFile) {
@@ -384,11 +384,11 @@ import * as z from "zod";
 // src/utils/find-tsconfig.ts
 import { promises as fs } from "fs";
 import path from "path";
-async function find(filename, options) {
+async function find(filename, options2) {
   let dir = path.dirname(path.resolve(filename));
-  const root = options?.root ? path.resolve(options.root) : null;
+  const root = options2?.root ? path.resolve(options2.root) : null;
   while (dir) {
-    const tsconfig = await tsconfigInDir(dir, options);
+    const tsconfig = await tsconfigInDir(dir, options2);
     if (tsconfig) {
       return tsconfig;
     } else {
@@ -405,11 +405,11 @@ async function find(filename, options) {
   }
   throw new Error(`no tsconfig file found for ${filename}`);
 }
-async function tsconfigInDir(dir, options) {
+async function tsconfigInDir(dir, options2) {
   const tsconfig = path.join(dir, "tsconfig.json");
   const jsconfig = path.join(dir, "jsconfig.json");
-  if (options?.tsConfigPaths) {
-    return options.tsConfigPaths.has(tsconfig) ? tsconfig : void 0;
+  if (options2?.tsConfigPaths) {
+    return options2.tsConfigPaths.has(tsconfig) ? tsconfig : void 0;
   }
   try {
     const stat = await fs.stat(tsconfig);
@@ -455,11 +455,10 @@ function isUsingSvelteKit(cwd) {
   return Object.keys(deps).some((dep) => dep === "@sveltejs/kit");
 }
 
-// node_modules/.pnpm/@antfu+ni@0.21.5/node_modules/@antfu/ni/dist/shared/ni.3ebb7310.mjs
+// ../../node_modules/.pnpm/@antfu+ni@0.21.12/node_modules/@antfu/ni/dist/shared/ni.f699cf8a.mjs
+import fs$1, { createWriteStream, createReadStream, promises, existsSync } from "node:fs";
 import path$3, { join as join$1, dirname, resolve } from "node:path";
 import process$2 from "node:process";
-import require$$0$7 from "readline";
-import require$$2 from "events";
 import { Buffer as Buffer$1 } from "node:buffer";
 import childProcess, { ChildProcess } from "node:child_process";
 import require$$0$2 from "child_process";
@@ -467,14 +466,14 @@ import require$$0$1 from "path";
 import require$$0 from "fs";
 import url, { fileURLToPath as fileURLToPath2 } from "node:url";
 import os$1, { constants } from "node:os";
-import require$$0$3 from "assert";
-import fs$1, { promises, createWriteStream, createReadStream, existsSync } from "node:fs";
-import require$$0$5 from "buffer";
-import require$$0$4 from "stream";
-import require$$2$1 from "util";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import require$$0$3 from "stream";
 import { debuglog } from "node:util";
-import require$$0$6 from "os";
+import require$$0$4 from "os";
 import require$$1 from "tty";
+import require$$0$5 from "readline";
+import require$$2 from "events";
+import require$$1$1 from "fs/promises";
 function npmRun(agent) {
   return (args) => {
     if (args.length > 1)
@@ -516,8 +515,8 @@ var bun = {
   "frozen": "bun install --no-save",
   "global": "bun add -g {0}",
   "add": "bun add {0}",
-  "upgrade": null,
-  "upgrade-interactive": null,
+  "upgrade": "bun update {0}",
+  "upgrade-interactive": "bun update {0}",
   "execute": "bunx {0}",
   "uninstall": "bun remove {0}",
   "global_uninstall": "bun remove -g {0}"
@@ -576,207 +575,6 @@ function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var { hasOwnProperty } = Object.prototype;
-var Node = class {
-  value;
-  next;
-  constructor(value) {
-    this.value = value;
-  }
-};
-var Queue = class {
-  #head;
-  #tail;
-  #size;
-  constructor() {
-    this.clear();
-  }
-  enqueue(value) {
-    const node = new Node(value);
-    if (this.#head) {
-      this.#tail.next = node;
-      this.#tail = node;
-    } else {
-      this.#head = node;
-      this.#tail = node;
-    }
-    this.#size++;
-  }
-  dequeue() {
-    const current = this.#head;
-    if (!current) {
-      return;
-    }
-    this.#head = this.#head.next;
-    this.#size--;
-    return current.value;
-  }
-  clear() {
-    this.#head = void 0;
-    this.#tail = void 0;
-    this.#size = 0;
-  }
-  get size() {
-    return this.#size;
-  }
-  *[Symbol.iterator]() {
-    let current = this.#head;
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-};
-function pLimit(concurrency) {
-  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-  }
-  const queue = new Queue();
-  let activeCount = 0;
-  const next = () => {
-    activeCount--;
-    if (queue.size > 0) {
-      queue.dequeue()();
-    }
-  };
-  const run2 = async (fn, resolve2, args) => {
-    activeCount++;
-    const result = (async () => fn(...args))();
-    resolve2(result);
-    try {
-      await result;
-    } catch {
-    }
-    next();
-  };
-  const enqueue = (fn, resolve2, args) => {
-    queue.enqueue(run2.bind(void 0, fn, resolve2, args));
-    (async () => {
-      await Promise.resolve();
-      if (activeCount < concurrency && queue.size > 0) {
-        queue.dequeue()();
-      }
-    })();
-  };
-  const generator = (fn, ...args) => new Promise((resolve2) => {
-    enqueue(fn, resolve2, args);
-  });
-  Object.defineProperties(generator, {
-    activeCount: {
-      get: () => activeCount
-    },
-    pendingCount: {
-      get: () => queue.size
-    },
-    clearQueue: {
-      value: () => {
-        queue.clear();
-      }
-    }
-  });
-  return generator;
-}
-var EndError = class extends Error {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-};
-var testElement = async (element, tester) => tester(await element);
-var finder = async (element) => {
-  const values = await Promise.all(element);
-  if (values[1] === true) {
-    throw new EndError(values[0]);
-  }
-  return false;
-};
-async function pLocate(iterable, tester, {
-  concurrency = Number.POSITIVE_INFINITY,
-  preserveOrder = true
-} = {}) {
-  const limit = pLimit(concurrency);
-  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
-  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
-  try {
-    await Promise.all(items.map((element) => checkLimit(finder, element)));
-  } catch (error) {
-    if (error instanceof EndError) {
-      return error.value;
-    }
-    throw error;
-  }
-}
-var typeMappings = {
-  directory: "isDirectory",
-  file: "isFile"
-};
-function checkType(type) {
-  if (type in typeMappings) {
-    return;
-  }
-  throw new Error(`Invalid type specified: ${type}`);
-}
-var matchType = (type, stat) => type === void 0 || stat[typeMappings[type]]();
-var toPath$1 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
-async function locatePath(paths, {
-  cwd = process$2.cwd(),
-  type = "file",
-  allowSymlinks = true,
-  concurrency,
-  preserveOrder
-} = {}) {
-  checkType(type);
-  cwd = toPath$1(cwd);
-  const statFunction = allowSymlinks ? promises.stat : promises.lstat;
-  return pLocate(paths, async (path_) => {
-    try {
-      const stat = await statFunction(path$3.resolve(cwd, path_));
-      return matchType(type, stat);
-    } catch {
-      return false;
-    }
-  }, { concurrency, preserveOrder });
-}
-var toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
-var findUpStop = Symbol("findUpStop");
-async function findUpMultiple(name, options = {}) {
-  let directory = path$3.resolve(toPath(options.cwd) || "");
-  const { root } = path$3.parse(directory);
-  const stopAt = path$3.resolve(directory, options.stopAt || root);
-  const limit = options.limit || Number.POSITIVE_INFINITY;
-  const paths = [name].flat();
-  const runMatcher = async (locateOptions) => {
-    if (typeof name !== "function") {
-      return locatePath(paths, locateOptions);
-    }
-    const foundPath = await name(locateOptions.cwd);
-    if (typeof foundPath === "string") {
-      return locatePath([foundPath], locateOptions);
-    }
-    return foundPath;
-  };
-  const matches = [];
-  while (true) {
-    const foundPath = await runMatcher({ ...options, cwd: directory });
-    if (foundPath === findUpStop) {
-      break;
-    }
-    if (foundPath) {
-      matches.push(path$3.resolve(directory, foundPath));
-    }
-    if (directory === stopAt || matches.length >= limit) {
-      break;
-    }
-    directory = path$3.dirname(directory);
-  }
-  return matches;
-}
-async function findUp(name, options = {}) {
-  const matches = await findUpMultiple(name, { ...options, limit: 1 });
-  return matches[0];
-}
-var customRcPath = process$2.env.NI_CONFIG_FILE;
-var home = process$2.platform === "win32" ? process$2.env.USERPROFILE : process$2.env.HOME;
-var defaultRcPath = path$3.join(home || "~/", ".nirc");
 var crossSpawn$1 = { exports: {} };
 var windows;
 var hasRequiredWindows;
@@ -787,8 +585,8 @@ function requireWindows() {
   windows = isexe2;
   isexe2.sync = sync2;
   var fs9 = require$$0;
-  function checkPathExt(path13, options) {
-    var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+  function checkPathExt2(path13, options2) {
+    var pathext = options2.pathExt !== void 0 ? options2.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
     }
@@ -804,19 +602,19 @@ function requireWindows() {
     }
     return false;
   }
-  function checkStat(stat, path13, options) {
+  function checkStat2(stat, path13, options2) {
     if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
-    return checkPathExt(path13, options);
+    return checkPathExt2(path13, options2);
   }
-  function isexe2(path13, options, cb) {
+  function isexe2(path13, options2, cb) {
     fs9.stat(path13, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path13, options));
+      cb(er, er ? false : checkStat2(stat, path13, options2));
     });
   }
-  function sync2(path13, options) {
-    return checkStat(fs9.statSync(path13), path13, options);
+  function sync2(path13, options2) {
+    return checkStat2(fs9.statSync(path13), path13, options2);
   }
   return windows;
 }
@@ -829,23 +627,23 @@ function requireMode() {
   mode = isexe2;
   isexe2.sync = sync2;
   var fs9 = require$$0;
-  function isexe2(path13, options, cb) {
+  function isexe2(path13, options2, cb) {
     fs9.stat(path13, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, options));
+      cb(er, er ? false : checkStat2(stat, options2));
     });
   }
-  function sync2(path13, options) {
-    return checkStat(fs9.statSync(path13), options);
+  function sync2(path13, options2) {
+    return checkStat2(fs9.statSync(path13), options2);
   }
-  function checkStat(stat, options) {
-    return stat.isFile() && checkMode(stat, options);
+  function checkStat2(stat, options2) {
+    return stat.isFile() && checkMode2(stat, options2);
   }
-  function checkMode(stat, options) {
+  function checkMode2(stat, options2) {
     var mod = stat.mode;
     var uid = stat.uid;
     var gid = stat.gid;
-    var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
-    var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+    var myUid = options2.uid !== void 0 ? options2.uid : process.getuid && process.getuid();
+    var myGid = options2.gid !== void 0 ? options2.gid : process.getgid && process.getgid();
     var u = parseInt("100", 8);
     var g = parseInt("010", 8);
     var o = parseInt("001", 8);
@@ -861,19 +659,19 @@ if (process.platform === "win32" || commonjsGlobal.TESTING_WINDOWS) {
 } else {
   core = requireMode();
 }
-var isexe_1 = isexe$2;
-isexe$2.sync = sync;
-function isexe$2(path13, options, cb) {
-  if (typeof options === "function") {
-    cb = options;
-    options = {};
+var isexe_1 = isexe$4;
+isexe$4.sync = sync$2;
+function isexe$4(path13, options2, cb) {
+  if (typeof options2 === "function") {
+    cb = options2;
+    options2 = {};
   }
   if (!cb) {
     if (typeof Promise !== "function") {
       throw new TypeError("callback not provided");
     }
     return new Promise(function(resolve2, reject) {
-      isexe$2(path13, options || {}, function(er, is) {
+      isexe$4(path13, options2 || {}, function(er, is) {
         if (er) {
           reject(er);
         } else {
@@ -882,9 +680,9 @@ function isexe$2(path13, options, cb) {
       });
     });
   }
-  core(path13, options || {}, function(er, is) {
+  core(path13, options2 || {}, function(er, is) {
     if (er) {
-      if (er.code === "EACCES" || options && options.ignoreErrors) {
+      if (er.code === "EACCES" || options2 && options2.ignoreErrors) {
         er = null;
         is = false;
       }
@@ -892,11 +690,11 @@ function isexe$2(path13, options, cb) {
     cb(er, is);
   });
 }
-function sync(path13, options) {
+function sync$2(path13, options2) {
   try {
-    return core.sync(path13, options || {});
+    return core.sync(path13, options2 || {});
   } catch (er) {
-    if (options && options.ignoreErrors || er.code === "EACCES") {
+    if (options2 && options2.ignoreErrors || er.code === "EACCES") {
       return false;
     } else {
       throw er;
@@ -906,7 +704,7 @@ function sync(path13, options) {
 var isWindows$1 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
 var path$2 = require$$0$1;
 var COLON = isWindows$1 ? ";" : ":";
-var isexe$1 = isexe_1;
+var isexe$3 = isexe_1;
 var getNotFoundError$1 = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
 var getPathInfo$1 = (cmd, opt) => {
   const colon = opt.colon || COLON;
@@ -950,7 +748,7 @@ var which$3 = (cmd, opt, cb) => {
     if (ii === pathExt.length)
       return resolve2(step(i + 1));
     const ext = pathExt[ii];
-    isexe$1(p + ext, { pathExt: pathExtExe }, (er, is) => {
+    isexe$3(p + ext, { pathExt: pathExtExe }, (er, is) => {
       if (!er && is) {
         if (opt.all)
           found.push(p + ext);
@@ -974,7 +772,7 @@ var whichSync$1 = (cmd, opt) => {
     for (let j = 0; j < pathExt.length; j++) {
       const cur = p + pathExt[j];
       try {
-        const is = isexe$1.sync(cur, { pathExt: pathExtExe });
+        const is = isexe$3.sync(cur, { pathExt: pathExtExe });
         if (is) {
           if (opt.all)
             found.push(cur);
@@ -994,9 +792,9 @@ var whichSync$1 = (cmd, opt) => {
 var which_1 = which$3;
 which$3.sync = whichSync$1;
 var pathKey$2 = { exports: {} };
-var pathKey$1 = (options = {}) => {
-  const environment = options.env || process.env;
-  const platform = options.platform || process.platform;
+var pathKey$1 = (options2 = {}) => {
+  const environment = options2.env || process.env;
+  const platform = options2.platform || process.platform;
   if (platform !== "win32") {
     return "PATH";
   }
@@ -1092,7 +890,7 @@ var path7 = require$$0$1;
 var resolveCommand = resolveCommand_1;
 var escape = _escape;
 var readShebang = readShebang_1;
-var isWin$2 = process.platform === "win32";
+var isWin$1 = process.platform === "win32";
 var isExecutableRegExp = /\.(?:com|exe)$/i;
 var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
 function detectShebang(parsed) {
@@ -1106,7 +904,7 @@ function detectShebang(parsed) {
   return parsed.file;
 }
 function parseNonShell(parsed) {
-  if (!isWin$2) {
+  if (!isWin$1) {
     return parsed;
   }
   const commandFile = detectShebang(parsed);
@@ -1123,27 +921,27 @@ function parseNonShell(parsed) {
   }
   return parsed;
 }
-function parse$1(command, args, options) {
+function parse$1(command, args, options2) {
   if (args && !Array.isArray(args)) {
-    options = args;
+    options2 = args;
     args = null;
   }
   args = args ? args.slice(0) : [];
-  options = Object.assign({}, options);
+  options2 = Object.assign({}, options2);
   const parsed = {
     command,
     args,
-    options,
+    options: options2,
     file: void 0,
     original: {
       command,
       args
     }
   };
-  return options.shell ? parsed : parseNonShell(parsed);
+  return options2.shell ? parsed : parseNonShell(parsed);
 }
 var parse_1 = parse$1;
-var isWin$1 = process.platform === "win32";
+var isWin = process.platform === "win32";
 function notFoundError(original, syscall) {
   return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
     code: "ENOENT",
@@ -1154,7 +952,7 @@ function notFoundError(original, syscall) {
   });
 }
 function hookChildProcess(cp2, parsed) {
-  if (!isWin$1) {
+  if (!isWin) {
     return;
   }
   const originalEmit = cp2.emit;
@@ -1169,13 +967,13 @@ function hookChildProcess(cp2, parsed) {
   };
 }
 function verifyENOENT(status, parsed) {
-  if (isWin$1 && status === 1 && !parsed.file) {
+  if (isWin && status === 1 && !parsed.file) {
     return notFoundError(parsed.original, "spawn");
   }
   return null;
 }
 function verifyENOENTSync(status, parsed) {
-  if (isWin$1 && status === 1 && !parsed.file) {
+  if (isWin && status === 1 && !parsed.file) {
     return notFoundError(parsed.original, "spawnSync");
   }
   return null;
@@ -1189,14 +987,14 @@ var enoent$1 = {
 var cp = require$$0$2;
 var parse = parse_1;
 var enoent = enoent$1;
-function spawn(command, args, options) {
-  const parsed = parse(command, args, options);
+function spawn(command, args, options2) {
+  const parsed = parse(command, args, options2);
   const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
   enoent.hookChildProcess(spawned, parsed);
   return spawned;
 }
-function spawnSync(command, args, options) {
-  const parsed = parse(command, args, options);
+function spawnSync(command, args, options2) {
+  const parsed = parse(command, args, options2);
   const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
   result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
   return result;
@@ -1219,22 +1017,22 @@ function stripFinalNewline(input) {
   }
   return input;
 }
-function pathKey(options = {}) {
+function pathKey(options2 = {}) {
   const {
     env: env2 = process.env,
     platform = process.platform
-  } = options;
+  } = options2;
   if (platform !== "win32") {
     return "PATH";
   }
   return Object.keys(env2).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
 }
-function npmRunPath(options = {}) {
+function npmRunPath(options2 = {}) {
   const {
     cwd = process$2.cwd(),
     path: path_ = process$2.env[pathKey()],
     execPath = process$2.execPath
-  } = options;
+  } = options2;
   let previous;
   const cwdString = cwd instanceof URL ? url.fileURLToPath(cwd) : cwd;
   let cwdPath = path$3.resolve(cwdString);
@@ -1247,11 +1045,11 @@ function npmRunPath(options = {}) {
   result.push(path$3.resolve(cwdString, execPath, ".."));
   return [...result, path_].join(path$3.delimiter);
 }
-function npmRunPathEnv({ env: env2 = process$2.env, ...options } = {}) {
+function npmRunPathEnv({ env: env2 = process$2.env, ...options2 } = {}) {
   env2 = { ...env2 };
   const path13 = pathKey({ env: env2 });
-  options.path = env2[path13];
-  env2[path13] = npmRunPath(options);
+  options2.path = env2[path13];
+  env2[path13] = npmRunPath(options2);
   return env2;
 }
 var copyProperty = (to, from, property, ignoreNonConfigurable) => {
@@ -1298,7 +1096,7 @@ function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
   return to;
 }
 var calledFunctions = /* @__PURE__ */ new WeakMap();
-var onetime = (function_, options = {}) => {
+var onetime = (function_, options2 = {}) => {
   if (typeof function_ !== "function") {
     throw new TypeError("Expected a function");
   }
@@ -1310,7 +1108,7 @@ var onetime = (function_, options = {}) => {
     if (callCount === 1) {
       returnValue = function_.apply(this, arguments_);
       function_ = null;
-    } else if (options.throw === true) {
+    } else if (options2.throw === true) {
       throw new Error(`Function \`${functionName}\` can only be called once`);
     }
     return returnValue;
@@ -1611,8 +1409,8 @@ var SIGNALS = [
 ];
 var getSignals = () => {
   const realtimeSignals = getRealtimeSignals();
-  const signals = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
-  return signals;
+  const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
+  return signals2;
 };
 var normalizeSignal = ({
   name,
@@ -1630,8 +1428,8 @@ var normalizeSignal = ({
   return { name, number: number2, description, supported, action: action2, forced, standard };
 };
 var getSignalsByName = () => {
-  const signals = getSignals();
-  return Object.fromEntries(signals.map(getSignalByName));
+  const signals2 = getSignals();
+  return Object.fromEntries(signals2.map(getSignalByName));
 };
 var getSignalByName = ({
   name,
@@ -1644,13 +1442,16 @@ var getSignalByName = ({
 }) => [name, { name, number: number2, description, supported, action: action2, forced, standard }];
 var signalsByName = getSignalsByName();
 var getSignalsByNumber = () => {
-  const signals = getSignals();
+  const signals2 = getSignals();
   const length = SIGRTMAX + 1;
-  const signalsA = Array.from({ length }, (value, number2) => getSignalByNumber(number2, signals));
+  const signalsA = Array.from(
+    { length },
+    (value, number2) => getSignalByNumber(number2, signals2)
+  );
   return Object.assign({}, ...signalsA);
 };
-var getSignalByNumber = (number2, signals) => {
-  const signal = findSignalByNumber(number2, signals);
+var getSignalByNumber = (number2, signals2) => {
+  const signal = findSignalByNumber(number2, signals2);
   if (signal === void 0) {
     return {};
   }
@@ -1667,12 +1468,12 @@ var getSignalByNumber = (number2, signals) => {
     }
   };
 };
-var findSignalByNumber = (number2, signals) => {
-  const signal = signals.find(({ name }) => constants.signals[name] === number2);
+var findSignalByNumber = (number2, signals2) => {
+  const signal = signals2.find(({ name }) => constants.signals[name] === number2);
   if (signal !== void 0) {
     return signal;
   }
-  return signals.find((signalA) => signalA.number === number2);
+  return signals2.find((signalA) => signalA.number === number2);
 };
 getSignalsByNumber();
 var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
@@ -1705,7 +1506,7 @@ var makeError = ({
   timedOut,
   isCanceled,
   killed,
-  parsed: { options: { timeout } }
+  parsed: { options: { timeout, cwd = process$2.cwd() } }
 }) => {
   exitCode = exitCode === null ? void 0 : exitCode;
   signal = signal === null ? void 0 : signal;
@@ -1731,6 +1532,7 @@ ${error.message}` : execaMessage;
   error.signalDescription = signalDescription;
   error.stdout = stdout;
   error.stderr = stderr;
+  error.cwd = cwd;
   if (all !== void 0) {
     error.all = all;
   }
@@ -1744,16 +1546,16 @@ ${error.message}` : execaMessage;
   return error;
 };
 var aliases = ["stdin", "stdout", "stderr"];
-var hasAlias = (options) => aliases.some((alias) => options[alias] !== void 0);
-var normalizeStdio = (options) => {
-  if (!options) {
+var hasAlias = (options2) => aliases.some((alias) => options2[alias] !== void 0);
+var normalizeStdio = (options2) => {
+  if (!options2) {
     return;
   }
-  const { stdio } = options;
+  const { stdio } = options2;
   if (stdio === void 0) {
-    return aliases.map((alias) => options[alias]);
+    return aliases.map((alias) => options2[alias]);
   }
-  if (hasAlias(options)) {
+  if (hasAlias(options2)) {
     throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
   }
   if (typeof stdio === "string") {
@@ -1765,214 +1567,264 @@ var normalizeStdio = (options) => {
   const length = Math.max(stdio.length, aliases.length);
   return Array.from({ length }, (value, index) => stdio[index]);
 };
-var signalExit = { exports: {} };
-var signals$1 = { exports: {} };
-var hasRequiredSignals;
-function requireSignals() {
-  if (hasRequiredSignals)
-    return signals$1.exports;
-  hasRequiredSignals = 1;
-  (function(module) {
-    module.exports = [
-      "SIGABRT",
-      "SIGALRM",
-      "SIGHUP",
-      "SIGINT",
-      "SIGTERM"
-    ];
-    if (process.platform !== "win32") {
-      module.exports.push(
-        "SIGVTALRM",
-        "SIGXCPU",
-        "SIGXFSZ",
-        "SIGUSR2",
-        "SIGTRAP",
-        "SIGSYS",
-        "SIGQUIT",
-        "SIGIOT"
-        // should detect profiler and enable/disable accordingly.
-        // see #21
-        // 'SIGPROF'
-      );
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push(
+    "SIGALRM",
+    "SIGABRT",
+    "SIGVTALRM",
+    "SIGXCPU",
+    "SIGXFSZ",
+    "SIGUSR2",
+    "SIGTRAP",
+    "SIGSYS",
+    "SIGQUIT",
+    "SIGIOT"
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+var processOk = (process2) => !!process2 && typeof process2 === "object" && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global$1 = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global$1[kExitEmitter]) {
+      return global$1[kExitEmitter];
+    }
+    ObjectDefineProperty(global$1, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
     }
-    if (process.platform === "linux") {
-      module.exports.push(
-        "SIGIO",
-        "SIGPOLL",
-        "SIGPWR",
-        "SIGSTKFLT",
-        "SIGUNUSED"
-      );
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
     }
-  })(signals$1);
-  return signals$1.exports;
-}
-var process$1 = commonjsGlobal.process;
-var processOk = function(process2) {
-  return process2 && typeof process2 === "object" && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function";
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
 };
-if (!processOk(process$1)) {
-  signalExit.exports = function() {
-    return function() {
-    };
+var SignalExitBase = class {
+};
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
   };
-} else {
-  assert = require$$0$3;
-  signals = requireSignals();
-  isWin = /^win/i.test(process$1.platform);
-  EE = require$$2;
-  if (typeof EE !== "function") {
-    EE = EE.EventEmitter;
-  }
-  if (process$1.__signal_exit_emitter__) {
-    emitter = process$1.__signal_exit_emitter__;
-  } else {
-    emitter = process$1.__signal_exit_emitter__ = new EE();
-    emitter.count = 0;
-    emitter.emitted = {};
+};
+var SignalExitFallback = class extends SignalExitBase {
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
   }
-  if (!emitter.infinite) {
-    emitter.setMaxListeners(Infinity);
-    emitter.infinite = true;
+  unload() {
   }
-  signalExit.exports = function(cb, opts) {
-    if (!processOk(commonjsGlobal.process)) {
-      return function() {
+};
+var SignalExit = class extends SignalExitBase {
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #hupSig = process$1.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #emitter = new Emitter();
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process2) {
+    super();
+    this.#process = process2;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process2;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process2.kill(process2.pid, s);
+        }
       };
     }
-    assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
-    if (loaded === false) {
-      load();
+    this.#originalProcessReallyExit = process2.reallyExit;
+    this.#originalProcessEmit = process2.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {
+      };
     }
-    var ev = "exit";
-    if (opts && opts.alwaysLast) {
-      ev = "afterexit";
+    if (this.#loaded === false) {
+      this.load();
     }
-    var remove2 = function() {
-      emitter.removeListener(ev, cb);
-      if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
-        unload();
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
       }
     };
-    emitter.on(ev, cb);
-    return remove2;
-  };
-  unload = function unload2() {
-    if (!loaded || !processOk(commonjsGlobal.process)) {
+  }
+  load() {
+    if (this.#loaded) {
       return;
     }
-    loaded = false;
-    signals.forEach(function(sig) {
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
       try {
-        process$1.removeListener(sig, sigListeners[sig]);
-      } catch (er) {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {
       }
-    });
-    process$1.emit = originalProcessEmit;
-    process$1.reallyExit = originalProcessReallyExit;
-    emitter.count -= 1;
-  };
-  signalExit.exports.unload = unload;
-  emit = function emit2(event, code, signal) {
-    if (emitter.emitted[event]) {
-      return;
     }
-    emitter.emitted[event] = true;
-    emitter.emit(event, code, signal);
-  };
-  sigListeners = {};
-  signals.forEach(function(sig) {
-    sigListeners[sig] = function listener() {
-      if (!processOk(commonjsGlobal.process)) {
-        return;
-      }
-      var listeners = process$1.listeners(sig);
-      if (listeners.length === emitter.count) {
-        unload();
-        emit("exit", null, sig);
-        emit("afterexit", null, sig);
-        if (isWin && sig === "SIGHUP") {
-          sig = "SIGINT";
-        }
-        process$1.kill(process$1.pid, sig);
-      }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
     };
-  });
-  signalExit.exports.signals = function() {
-    return signals;
-  };
-  loaded = false;
-  load = function load2() {
-    if (loaded || !processOk(commonjsGlobal.process)) {
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
       return;
     }
-    loaded = true;
-    emitter.count += 1;
-    signals = signals.filter(function(sig) {
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
       try {
-        process$1.on(sig, sigListeners[sig]);
-        return true;
-      } catch (er) {
-        return false;
+        this.#process.removeListener(sig, listener);
+      } catch (_) {
       }
     });
-    process$1.emit = processEmit;
-    process$1.reallyExit = processReallyExit;
-  };
-  signalExit.exports.load = load;
-  originalProcessReallyExit = process$1.reallyExit;
-  processReallyExit = function processReallyExit2(code) {
-    if (!processOk(commonjsGlobal.process)) {
-      return;
-    }
-    process$1.exitCode = code || /* istanbul ignore next */
-    0;
-    emit("exit", process$1.exitCode, null);
-    emit("afterexit", process$1.exitCode, null);
-    originalProcessReallyExit.call(process$1, process$1.exitCode);
-  };
-  originalProcessEmit = process$1.emit;
-  processEmit = function processEmit2(ev, arg) {
-    if (ev === "exit" && processOk(commonjsGlobal.process)) {
-      if (arg !== void 0) {
-        process$1.exitCode = arg;
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
       }
-      var ret = originalProcessEmit.apply(this, arguments);
-      emit("exit", process$1.exitCode, null);
-      emit("afterexit", process$1.exitCode, null);
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
       return ret;
     } else {
-      return originalProcessEmit.apply(this, arguments);
-    }
-  };
-}
-var assert;
-var signals;
-var isWin;
-var EE;
-var emitter;
-var unload;
-var emit;
-var sigListeners;
-var loaded;
-var load;
-var originalProcessReallyExit;
-var processReallyExit;
-var originalProcessEmit;
-var processEmit;
-var signalExitExports = signalExit.exports;
-var onExit = /* @__PURE__ */ getDefaultExportFromCjs(signalExitExports);
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+};
+var process$1 = globalThis.process;
+var {
+  /**
+   * Called when the process is exiting, whether via signal, explicit
+   * exit, or running out of stuff to do.
+   *
+   * If the global process object is not suitable for instrumentation,
+   * then this will be a no-op.
+   *
+   * Returns a function that may be used to unload signal-exit.
+   */
+  onExit,
+  /**
+   * Load the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  load,
+  /**
+   * Unload the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  unload
+} = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
 var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
-var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
+var spawnedKill = (kill, signal = "SIGTERM", options2 = {}) => {
   const killResult = kill(signal);
-  setKillTimeout(kill, signal, options, killResult);
+  setKillTimeout(kill, signal, options2, killResult);
   return killResult;
 };
-var setKillTimeout = (kill, signal, options, killResult) => {
-  if (!shouldForceKill(signal, options, killResult)) {
+var setKillTimeout = (kill, signal, options2, killResult) => {
+  if (!shouldForceKill(signal, options2, killResult)) {
     return;
   }
-  const timeout = getForceKillAfterTimeout(options);
+  const timeout = getForceKillAfterTimeout(options2);
   const t = setTimeout(() => {
     kill("SIGKILL");
   }, timeout);
@@ -2032,11 +1884,11 @@ var setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
     removeExitHandler();
   });
 };
-function isStream(stream2) {
-  return stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
+function isStream(stream) {
+  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
 }
-function isWritableStream(stream2) {
-  return isStream(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
+function isWritableStream(stream) {
+  return isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
 }
 var isExecaChildProcess = (target) => target instanceof ChildProcess && typeof target.then === "function";
 var pipeToTarget = (spawned, streamName, target) => {
@@ -2068,96 +1920,179 @@ var addPipeMethods = (spawned) => {
     spawned.pipeAll = pipeToTarget.bind(void 0, spawned, "all");
   }
 };
-var getStream$2 = { exports: {} };
-var { PassThrough: PassThroughStream } = require$$0$4;
-var bufferStream$1 = (options) => {
-  options = { ...options };
-  const { array: array2 } = options;
-  let { encoding } = options;
-  const isBuffer = encoding === "buffer";
-  let objectMode = false;
-  if (array2) {
-    objectMode = !(encoding || isBuffer);
-  } else {
-    encoding = encoding || "utf8";
+var getStreamContents = async (stream, { init: init3, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
+  if (!isAsyncIterable(stream)) {
+    throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
   }
-  if (isBuffer) {
-    encoding = null;
+  const state = init3();
+  state.length = 0;
+  try {
+    for await (const chunk of stream) {
+      const chunkType = getChunkType(chunk);
+      const convertedChunk = convertChunk[chunkType](chunk, state);
+      appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+    }
+    appendFinalChunk({ state, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer });
+    return finalize(state);
+  } catch (error) {
+    error.bufferedData = finalize(state);
+    throw error;
   }
-  const stream2 = new PassThroughStream({ objectMode });
-  if (encoding) {
-    stream2.setEncoding(encoding);
+};
+var appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
+  const convertedChunk = getFinalChunk(state);
+  if (convertedChunk !== void 0) {
+    appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
   }
-  let length = 0;
-  const chunks = [];
-  stream2.on("data", (chunk) => {
-    chunks.push(chunk);
-    if (objectMode) {
-      length = chunks.length;
-    } else {
-      length += chunk.length;
-    }
-  });
-  stream2.getBufferedValue = () => {
-    if (array2) {
-      return chunks;
-    }
-    return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
-  };
-  stream2.getBufferedLength = () => length;
-  return stream2;
-};
-var { constants: BufferConstants } = require$$0$5;
-var stream = require$$0$4;
-var { promisify } = require$$2$1;
-var bufferStream = bufferStream$1;
-var streamPipelinePromisified = promisify(stream.pipeline);
+};
+var appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
+  const chunkSize = getSize(convertedChunk);
+  const newLength = state.length + chunkSize;
+  if (newLength <= maxBuffer) {
+    addNewChunk(convertedChunk, state, addChunk, newLength);
+    return;
+  }
+  const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
+  if (truncatedChunk !== void 0) {
+    addNewChunk(truncatedChunk, state, addChunk, maxBuffer);
+  }
+  throw new MaxBufferError();
+};
+var addNewChunk = (convertedChunk, state, addChunk, newLength) => {
+  state.contents = addChunk(convertedChunk, state, newLength);
+  state.length = newLength;
+};
+var isAsyncIterable = (stream) => typeof stream === "object" && stream !== null && typeof stream[Symbol.asyncIterator] === "function";
+var getChunkType = (chunk) => {
+  const typeOfChunk = typeof chunk;
+  if (typeOfChunk === "string") {
+    return "string";
+  }
+  if (typeOfChunk !== "object" || chunk === null) {
+    return "others";
+  }
+  if (globalThis.Buffer?.isBuffer(chunk)) {
+    return "buffer";
+  }
+  const prototypeName = objectToString.call(chunk);
+  if (prototypeName === "[object ArrayBuffer]") {
+    return "arrayBuffer";
+  }
+  if (prototypeName === "[object DataView]") {
+    return "dataView";
+  }
+  if (Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString.call(chunk.buffer) === "[object ArrayBuffer]") {
+    return "typedArray";
+  }
+  return "others";
+};
+var { toString: objectToString } = Object.prototype;
 var MaxBufferError = class extends Error {
+  name = "MaxBufferError";
   constructor() {
     super("maxBuffer exceeded");
-    this.name = "MaxBufferError";
   }
 };
-async function getStream(inputStream, options) {
-  if (!inputStream) {
-    throw new Error("Expected a stream");
+var identity = (value) => value;
+var noop$1 = () => void 0;
+var getContentsProp = ({ contents }) => contents;
+var throwObjectStream = (chunk) => {
+  throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
+};
+var getLengthProp = (convertedChunk) => convertedChunk.length;
+async function getStreamAsArrayBuffer(stream, options2) {
+  return getStreamContents(stream, arrayBufferMethods, options2);
+}
+var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) });
+var useTextEncoder = (chunk) => textEncoder.encode(chunk);
+var textEncoder = new TextEncoder();
+var useUint8Array = (chunk) => new Uint8Array(chunk);
+var useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+var truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
+  const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
+  new Uint8Array(newContents).set(convertedChunk, previousLength);
+  return newContents;
+};
+var resizeArrayBufferSlow = (contents, length) => {
+  if (length <= contents.byteLength) {
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+};
+var resizeArrayBuffer = (contents, length) => {
+  if (length <= contents.maxByteLength) {
+    contents.resize(length);
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+};
+var getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
+var SCALE_FACTOR = 2;
+var finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length);
+var hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype;
+var arrayBufferMethods = {
+  init: initArrayBuffer,
+  convertChunk: {
+    string: useTextEncoder,
+    buffer: useUint8Array,
+    arrayBuffer: useUint8Array,
+    dataView: useUint8ArrayWithOffset,
+    typedArray: useUint8ArrayWithOffset,
+    others: throwObjectStream
+  },
+  getSize: getLengthProp,
+  truncateChunk: truncateArrayBufferChunk,
+  addChunk: addArrayBufferChunk,
+  getFinalChunk: noop$1,
+  finalize: finalizeArrayBuffer
+};
+async function getStreamAsBuffer(stream, options2) {
+  if (!("Buffer" in globalThis)) {
+    throw new Error("getStreamAsBuffer() is only supported in Node.js");
   }
-  options = {
-    maxBuffer: Infinity,
-    ...options
-  };
-  const { maxBuffer } = options;
-  const stream2 = bufferStream(options);
-  await new Promise((resolve2, reject) => {
-    const rejectPromise = (error) => {
-      if (error && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-        error.bufferedData = stream2.getBufferedValue();
-      }
-      reject(error);
-    };
-    (async () => {
-      try {
-        await streamPipelinePromisified(inputStream, stream2);
-        resolve2();
-      } catch (error) {
-        rejectPromise(error);
-      }
-    })();
-    stream2.on("data", () => {
-      if (stream2.getBufferedLength() > maxBuffer) {
-        rejectPromise(new MaxBufferError());
-      }
-    });
-  });
-  return stream2.getBufferedValue();
+  try {
+    return arrayBufferToNodeBuffer(await getStreamAsArrayBuffer(stream, options2));
+  } catch (error) {
+    if (error.bufferedData !== void 0) {
+      error.bufferedData = arrayBufferToNodeBuffer(error.bufferedData);
+    }
+    throw error;
+  }
+}
+var arrayBufferToNodeBuffer = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
+async function getStreamAsString(stream, options2) {
+  return getStreamContents(stream, stringMethods, options2);
 }
-getStream$2.exports = getStream;
-getStream$2.exports.buffer = (stream2, options) => getStream(stream2, { ...options, encoding: "buffer" });
-getStream$2.exports.array = (stream2, options) => getStream(stream2, { ...options, array: true });
-getStream$2.exports.MaxBufferError = MaxBufferError;
-var getStreamExports = getStream$2.exports;
-var getStream$1 = /* @__PURE__ */ getDefaultExportFromCjs(getStreamExports);
-var { PassThrough } = require$$0$4;
+var initString = () => ({ contents: "", textDecoder: new TextDecoder() });
+var useTextDecoder = (chunk, { textDecoder }) => textDecoder.decode(chunk, { stream: true });
+var addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk;
+var truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var getFinalStringChunk = ({ textDecoder }) => {
+  const finalChunk = textDecoder.decode();
+  return finalChunk === "" ? void 0 : finalChunk;
+};
+var stringMethods = {
+  init: initString,
+  convertChunk: {
+    string: identity,
+    buffer: useTextDecoder,
+    arrayBuffer: useTextDecoder,
+    dataView: useTextDecoder,
+    typedArray: useTextDecoder,
+    others: throwObjectStream
+  },
+  getSize: getLengthProp,
+  truncateChunk: truncateStringChunk,
+  addChunk: addStringChunk,
+  getFinalChunk: getFinalStringChunk,
+  finalize: getContentsProp
+};
+var { PassThrough } = require$$0$3;
 var mergeStream = function() {
   var sources = [];
   var output = new PassThrough({ objectMode: true });
@@ -2203,8 +2138,8 @@ var getInput = ({ input, inputFile }) => {
   validateInputOptions(input);
   return createReadStream(inputFile);
 };
-var handleInput = (spawned, options) => {
-  const input = getInput(options);
+var handleInput = (spawned, options2) => {
+  const input = getInput(options2);
   if (input === void 0) {
     return;
   }
@@ -2227,25 +2162,33 @@ var makeAllStream = (spawned, { all }) => {
   }
   return mixed;
 };
-var getBufferedData = async (stream2, streamPromise) => {
-  if (!stream2 || streamPromise === void 0) {
+var getBufferedData = async (stream, streamPromise) => {
+  if (!stream || streamPromise === void 0) {
     return;
   }
-  stream2.destroy();
+  await setTimeout$1(0);
+  stream.destroy();
   try {
     return await streamPromise;
   } catch (error) {
     return error.bufferedData;
   }
 };
-var getStreamPromise = (stream2, { encoding, buffer, maxBuffer }) => {
-  if (!stream2 || !buffer) {
+var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
+  if (!stream || !buffer) {
     return;
   }
-  if (encoding) {
-    return getStream$1(stream2, { encoding, maxBuffer });
+  if (encoding === "utf8" || encoding === "utf-8") {
+    return getStreamAsString(stream, { maxBuffer });
   }
-  return getStream$1.buffer(stream2, { maxBuffer });
+  if (encoding === null || encoding === "buffer") {
+    return getStreamAsBuffer(stream, { maxBuffer });
+  }
+  return applyEncoding(stream, maxBuffer, encoding);
+};
+var applyEncoding = async (stream, maxBuffer, encoding) => {
+  const buffer = await getStreamAsBuffer(stream, { maxBuffer });
+  return buffer.toString(encoding);
 };
 var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
   const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
@@ -2294,12 +2237,11 @@ var normalizeArgs = (file, args = []) => {
   return [file, ...args];
 };
 var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
-var DOUBLE_QUOTES_REGEXP = /"/g;
 var escapeArg = (arg) => {
   if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
     return arg;
   }
-  return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
+  return `"${arg.replaceAll('"', '\\"')}"`;
 };
 var joinCommand = (file, args) => normalizeArgs(file, args).join(" ");
 var getEscapedCommand = (file, args) => normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" ");
@@ -2307,7 +2249,7 @@ var SPACES_REGEXP = / +/g;
 var parseCommand = (command) => {
   const tokens = [];
   for (const token of command.trim().split(SPACES_REGEXP)) {
-    const previousToken = tokens[tokens.length - 1];
+    const previousToken = tokens.at(-1);
     if (previousToken && previousToken.endsWith("\\")) {
       tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
     } else {
@@ -2337,18 +2279,18 @@ var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) =>
   }
   return env2;
 };
-var handleArguments = (file, args, options = {}) => {
-  const parsed = crossSpawn._parse(file, args, options);
+var handleArguments = (file, args, options2 = {}) => {
+  const parsed = crossSpawn._parse(file, args, options2);
   file = parsed.command;
   args = parsed.args;
-  options = parsed.options;
-  options = {
+  options2 = parsed.options;
+  options2 = {
     maxBuffer: DEFAULT_MAX_BUFFER,
     buffer: true,
     stripFinalNewline: true,
     extendEnv: true,
     preferLocal: false,
-    localDir: options.cwd || process$2.cwd(),
+    localDir: options2.cwd || process$2.cwd(),
     execPath: process$2.execPath,
     encoding: "utf8",
     reject: true,
@@ -2356,26 +2298,26 @@ var handleArguments = (file, args, options = {}) => {
     all: false,
     windowsHide: true,
     verbose: verboseDefault,
-    ...options
+    ...options2
   };
-  options.env = getEnv(options);
-  options.stdio = normalizeStdio(options);
+  options2.env = getEnv(options2);
+  options2.stdio = normalizeStdio(options2);
   if (process$2.platform === "win32" && path$3.basename(file, ".exe") === "cmd") {
     args.unshift("/q");
   }
-  return { file, args, options, parsed };
+  return { file, args, options: options2, parsed };
 };
-var handleOutput = (options, value, error) => {
+var handleOutput = (options2, value, error) => {
   if (typeof value !== "string" && !Buffer$1.isBuffer(value)) {
     return error === void 0 ? void 0 : "";
   }
-  if (options.stripFinalNewline) {
+  if (options2.stripFinalNewline) {
     return stripFinalNewline(value);
   }
   return value;
 };
-function execa(file, args, options) {
-  const parsed = handleArguments(file, args, options);
+function execa(file, args, options2) {
+  const parsed = handleArguments(file, args, options2);
   const command = joinCommand(file, args);
   const escapedCommand = getEscapedCommand(file, args);
   logCommand(escapedCommand, parsed.options);
@@ -2451,9 +2393,207 @@ function execa(file, args, options) {
   mergePromise(spawned, handlePromiseOnce);
   return spawned;
 }
-function execaCommand(command, options) {
+function execaCommand(command, options2) {
   const [file, ...args] = parseCommand(command);
-  return execa(file, args, options);
+  return execa(file, args, options2);
+}
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run2 = async (fn, resolve2, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve2(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve2, args) => {
+    queue.enqueue(run2.bind(void 0, fn, resolve2, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve2) => {
+    enqueue(fn, resolve2, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+var EndError = class extends Error {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+var testElement = async (element, tester) => tester(await element);
+var finder = async (element) => {
+  const values = await Promise.all(element);
+  if (values[1] === true) {
+    throw new EndError(values[0]);
+  }
+  return false;
+};
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
+}
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat) => stat[typeMappings[type]]();
+var toPath$1 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+async function locatePath(paths, {
+  cwd = process$2.cwd(),
+  type = "file",
+  allowSymlinks = true,
+  concurrency,
+  preserveOrder
+} = {}) {
+  checkType(type);
+  cwd = toPath$1(cwd);
+  const statFunction = allowSymlinks ? promises.stat : promises.lstat;
+  return pLocate(paths, async (path_) => {
+    try {
+      const stat = await statFunction(path$3.resolve(cwd, path_));
+      return matchType(type, stat);
+    } catch {
+      return false;
+    }
+  }, { concurrency, preserveOrder });
+}
+var toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+var findUpStop = Symbol("findUpStop");
+async function findUpMultiple(name, options2 = {}) {
+  let directory = path$3.resolve(toPath(options2.cwd) || "");
+  const { root } = path$3.parse(directory);
+  const stopAt = path$3.resolve(directory, options2.stopAt || root);
+  const limit = options2.limit || Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = async (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePath(paths, locateOptions);
+    }
+    const foundPath = await name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePath([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = await runMatcher({ ...options2, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path$3.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path$3.dirname(directory);
+  }
+  return matches;
+}
+async function findUp(name, options2 = {}) {
+  const matches = await findUpMultiple(name, { ...options2, limit: 1 });
+  return matches[0];
 }
 var ESC$1 = "\x1B[";
 var OSC = "\x1B]";
@@ -2542,32 +2682,32 @@ ansiEscapes.link = (text2, url2) => {
     BEL
   ].join("");
 };
-ansiEscapes.image = (buffer, options = {}) => {
+ansiEscapes.image = (buffer, options2 = {}) => {
   let returnValue = `${OSC}1337;File=inline=1`;
-  if (options.width) {
-    returnValue += `;width=${options.width}`;
+  if (options2.width) {
+    returnValue += `;width=${options2.width}`;
   }
-  if (options.height) {
-    returnValue += `;height=${options.height}`;
+  if (options2.height) {
+    returnValue += `;height=${options2.height}`;
   }
-  if (options.preserveAspectRatio === false) {
+  if (options2.preserveAspectRatio === false) {
     returnValue += ";preserveAspectRatio=0";
   }
   return returnValue + ":" + buffer.toString("base64") + BEL;
 };
 ansiEscapes.iTerm = {
   setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
-  annotation: (message, options = {}) => {
+  annotation: (message, options2 = {}) => {
     let returnValue = `${OSC}1337;`;
-    const hasX = typeof options.x !== "undefined";
-    const hasY = typeof options.y !== "undefined";
-    if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== "undefined")) {
+    const hasX = typeof options2.x !== "undefined";
+    const hasY = typeof options2.y !== "undefined";
+    if ((hasX || hasY) && !(hasX && hasY && typeof options2.length !== "undefined")) {
       throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
     }
     message = message.replace(/\|/g, "");
-    returnValue += options.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
-    if (options.length > 0) {
-      returnValue += (hasX ? [message, options.length, options.x, options.y] : [options.length, message]).join("|");
+    returnValue += options2.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
+    if (options2.length > 0) {
+      returnValue += (hasX ? [message, options2.length, options2.x, options2.y] : [options2.length, message]).join("|");
     } else {
       returnValue += message;
     }
@@ -2580,7 +2720,7 @@ var hasFlag$2 = (flag, argv = process.argv) => {
   const terminatorPosition = argv.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 };
-var os = require$$0$6;
+var os = require$$0$4;
 var tty = require$$1;
 var hasFlag$1 = hasFlag$2;
 var { env } = process;
@@ -2666,8 +2806,8 @@ function supportsColor$1(haveStream, streamIsTTY) {
   }
   return min;
 }
-function getSupportLevel(stream2) {
-  const level = supportsColor$1(stream2, stream2 && stream2.isTTY);
+function getSupportLevel(stream) {
+  const level = supportsColor$1(stream, stream && stream.isTTY);
   return translateLevel(level);
 }
 var supportsColor_1 = {
@@ -2693,7 +2833,7 @@ function parseVersion(versionString) {
     patch: versions[2]
   };
 }
-function supportsHyperlink(stream2) {
+function supportsHyperlink(stream) {
   const { env: env2 } = process;
   if ("FORCE_HYPERLINK" in env2) {
     return !(env2.FORCE_HYPERLINK.length > 0 && parseInt(env2.FORCE_HYPERLINK, 10) === 0);
@@ -2704,10 +2844,10 @@ function supportsHyperlink(stream2) {
   if (hasFlag("hyperlink=true") || hasFlag("hyperlink=always")) {
     return true;
   }
-  if (!supportsColor.supportsColor(stream2)) {
+  if (!supportsColor.supportsColor(stream)) {
     return false;
   }
-  if (stream2 && !stream2.isTTY) {
+  if (stream && !stream.isTTY) {
     return false;
   }
   if (process.platform === "win32") {
@@ -2747,17 +2887,17 @@ var supportsHyperlinks = {
   stderr: supportsHyperlink(process.stderr)
 };
 var supportsHyperlinks$1 = /* @__PURE__ */ getDefaultExportFromCjs(supportsHyperlinks);
-function terminalLink(text2, url2, { target = "stdout", ...options } = {}) {
+function terminalLink(text2, url2, { target = "stdout", ...options2 } = {}) {
   if (!supportsHyperlinks$1[target]) {
-    if (options.fallback === false) {
+    if (options2.fallback === false) {
       return text2;
     }
-    return typeof options.fallback === "function" ? options.fallback(text2, url2) : `${text2} (\u200B${url2}\u200B)`;
+    return typeof options2.fallback === "function" ? options2.fallback(text2, url2) : `${text2} (\u200B${url2}\u200B)`;
   }
   return ansiEscapes.link(text2, url2);
 }
 terminalLink.isSupported = supportsHyperlinks$1.stdout;
-terminalLink.stderr = (text2, url2, options = {}) => terminalLink(text2, url2, { target: "stderr", ...options });
+terminalLink.stderr = (text2, url2, options2 = {}) => terminalLink(text2, url2, { target: "stderr", ...options2 });
 terminalLink.stderr.isSupported = supportsHyperlinks$1.stderr;
 var prompts$3 = {};
 var FORCE_COLOR$1;
@@ -3083,7 +3223,7 @@ var util = {
   wrap: wrap$3,
   entriesToDisplay: entriesToDisplay$3
 };
-var readline = require$$0$7;
+var readline = require$$0$5;
 var { action } = util;
 var EventEmitter = require$$2;
 var { beep, cursor: cursor$9 } = src;
@@ -4287,28 +4427,28 @@ Instructions:
     return prefix + title + color$3.gray(desc || "");
   }
   // shared with autocompleteMultiselect
-  paginateOptions(options) {
-    if (options.length === 0) {
+  paginateOptions(options2) {
+    if (options2.length === 0) {
       return color$3.red("No matches for this query.");
     }
-    let { startIndex, endIndex } = entriesToDisplay$1(this.cursor, options.length, this.optionsPerPage);
+    let { startIndex, endIndex } = entriesToDisplay$1(this.cursor, options2.length, this.optionsPerPage);
     let prefix, styledOptions = [];
     for (let i = startIndex; i < endIndex; i++) {
       if (i === startIndex && startIndex > 0) {
         prefix = figures$2.arrowUp;
-      } else if (i === endIndex - 1 && endIndex < options.length) {
+      } else if (i === endIndex - 1 && endIndex < options2.length) {
         prefix = figures$2.arrowDown;
       } else {
         prefix = " ";
       }
-      styledOptions.push(this.renderOption(this.cursor, options[i], i, prefix));
+      styledOptions.push(this.renderOption(this.cursor, options2[i], i, prefix));
     }
     return "\n" + styledOptions.join("\n");
   }
   // shared with autocomleteMultiselect
-  renderOptions(options) {
+  renderOptions(options2) {
     if (!this.done) {
-      return this.paginateOptions(options);
+      return this.paginateOptions(options2);
     }
     return "";
   }
@@ -4935,7 +5075,152 @@ function override(answers) {
 var lib$1 = Object.assign(prompt, { prompt, prompts: prompts$2, inject, override });
 var prompts = lib$1;
 var prompts$1 = /* @__PURE__ */ getDefaultExportFromCjs(prompts);
-var isexe = isexe_1;
+var cjs = {};
+var posix$1 = {};
+Object.defineProperty(posix$1, "__esModule", { value: true });
+posix$1.sync = posix$1.isexe = void 0;
+var fs_1$1 = require$$0;
+var promises_1$1 = require$$1$1;
+var isexe$2 = async (path13, options2 = {}) => {
+  const { ignoreErrors = false } = options2;
+  try {
+    return checkStat$1(await (0, promises_1$1.stat)(path13), options2);
+  } catch (e) {
+    const er = e;
+    if (ignoreErrors || er.code === "EACCES")
+      return false;
+    throw er;
+  }
+};
+posix$1.isexe = isexe$2;
+var sync$1 = (path13, options2 = {}) => {
+  const { ignoreErrors = false } = options2;
+  try {
+    return checkStat$1((0, fs_1$1.statSync)(path13), options2);
+  } catch (e) {
+    const er = e;
+    if (ignoreErrors || er.code === "EACCES")
+      return false;
+    throw er;
+  }
+};
+posix$1.sync = sync$1;
+var checkStat$1 = (stat, options2) => stat.isFile() && checkMode(stat, options2);
+var checkMode = (stat, options2) => {
+  const myUid = options2.uid ?? process.getuid?.();
+  const myGroups = options2.groups ?? process.getgroups?.() ?? [];
+  const myGid = options2.gid ?? process.getgid?.() ?? myGroups[0];
+  if (myUid === void 0 || myGid === void 0) {
+    throw new Error("cannot get uid or gid");
+  }
+  const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]);
+  const mod = stat.mode;
+  const uid = stat.uid;
+  const gid = stat.gid;
+  const u = parseInt("100", 8);
+  const g = parseInt("010", 8);
+  const o = parseInt("001", 8);
+  const ug = u | g;
+  return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0);
+};
+var win32 = {};
+Object.defineProperty(win32, "__esModule", { value: true });
+win32.sync = win32.isexe = void 0;
+var fs_1 = require$$0;
+var promises_1 = require$$1$1;
+var isexe$1 = async (path13, options2 = {}) => {
+  const { ignoreErrors = false } = options2;
+  try {
+    return checkStat(await (0, promises_1.stat)(path13), path13, options2);
+  } catch (e) {
+    const er = e;
+    if (ignoreErrors || er.code === "EACCES")
+      return false;
+    throw er;
+  }
+};
+win32.isexe = isexe$1;
+var sync = (path13, options2 = {}) => {
+  const { ignoreErrors = false } = options2;
+  try {
+    return checkStat((0, fs_1.statSync)(path13), path13, options2);
+  } catch (e) {
+    const er = e;
+    if (ignoreErrors || er.code === "EACCES")
+      return false;
+    throw er;
+  }
+};
+win32.sync = sync;
+var checkPathExt = (path13, options2) => {
+  const { pathExt = process.env.PATHEXT || "" } = options2;
+  const peSplit = pathExt.split(";");
+  if (peSplit.indexOf("") !== -1) {
+    return true;
+  }
+  for (let i = 0; i < peSplit.length; i++) {
+    const p = peSplit[i].toLowerCase();
+    const ext = path13.substring(path13.length - p.length).toLowerCase();
+    if (p && ext === p) {
+      return true;
+    }
+  }
+  return false;
+};
+var checkStat = (stat, path13, options2) => stat.isFile() && checkPathExt(path13, options2);
+var options = {};
+Object.defineProperty(options, "__esModule", { value: true });
+(function(exports) {
+  var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = commonjsGlobal && commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = commonjsGlobal && commonjsGlobal.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __exportStar = commonjsGlobal && commonjsGlobal.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.sync = exports.isexe = exports.posix = exports.win32 = void 0;
+  const posix2 = __importStar(posix$1);
+  exports.posix = posix2;
+  const win32$1 = __importStar(win32);
+  exports.win32 = win32$1;
+  __exportStar(options, exports);
+  const platform = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+  const impl = platform === "win32" ? win32$1 : posix2;
+  exports.isexe = impl.isexe;
+  exports.sync = impl.sync;
+})(cjs);
+var { isexe, sync: isexeSync } = cjs;
 var { join, delimiter, sep: sep2, posix } = require$$0$1;
 var isWindows = process.platform === "win32";
 var rSlash = new RegExp(`[${posix.sep}${sep2 === posix.sep ? "" : sep2}]`.replace(/(\\)/g, "\\$1"));
@@ -4954,11 +5239,7 @@ var getPathInfo = (cmd, {
   ];
   if (isWindows) {
     const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
-    const pathExt = pathExtExe.split(optDelimiter).reduce((acc, item2) => {
-      acc.push(item2);
-      acc.push(item2.toLowerCase());
-      return acc;
-    }, []);
+    const pathExt = pathExtExe.split(optDelimiter).flatMap((item2) => [item2, item2.toLowerCase()]);
     if (cmd.includes(".") && pathExt[0] !== "") {
       pathExt.unshift("");
     }
@@ -5002,7 +5283,7 @@ var whichSync = (cmd, opt = {}) => {
     const p = getPathPart(pathEnvPart, cmd);
     for (const ext of pathExt) {
       const withExt = p + ext;
-      const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+      const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
       if (is) {
         if (!opt.all) {
           return withExt;
@@ -5039,16 +5320,18 @@ async function detect({ autoInstall, programmatic, cwd } = {}) {
     try {
       const pkg = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf8"));
       if (typeof pkg.packageManager === "string") {
-        const [name, ver] = pkg.packageManager.split("@");
+        const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
         version = ver;
-        if (name === "yarn" && Number.parseInt(ver) > 1)
+        if (name === "yarn" && Number.parseInt(ver) > 1) {
           agent = "yarn@berry";
-        else if (name === "pnpm" && Number.parseInt(ver) < 7)
+          version = "berry";
+        } else if (name === "pnpm" && Number.parseInt(ver) < 7) {
           agent = "pnpm@6";
-        else if (name in AGENTS)
+        } else if (name in AGENTS) {
           agent = name;
-        else if (!programmatic)
+        } else if (!programmatic) {
           console.warn("[ni] Unknown packageManager:", pkg.packageManager);
+        }
       }
     } catch {
     }
@@ -5070,10 +5353,13 @@ async function detect({ autoInstall, programmatic, cwd } = {}) {
       if (!tryInstall)
         process$2.exit(1);
     }
-    await execaCommand(`npm i -g ${agent}${version ? `@${version}` : ""}`, { stdio: "inherit", cwd });
+    await execaCommand(`npm i -g ${agent.split("@")[0]}${version ? `@${version}` : ""}`, { stdio: "inherit", cwd });
   }
   return agent;
 }
+var customRcPath = process$2.env.NI_CONFIG_FILE;
+var home = process$2.platform === "win32" ? process$2.env.USERPROFILE : process$2.env.HOME;
+var defaultRcPath = path$3.join(home || "~/", ".nirc");
 var FORCE_COLOR;
 var NODE_DISABLE_COLORS;
 var NO_COLOR;
@@ -5468,13 +5754,13 @@ async function getItemTargetPath(config, item2, override2) {
 }
 async function fetchRegistry(paths) {
   try {
-    let options = {};
+    let options2 = {};
     if (proxyUrl) {
-      options.agent = new HttpsProxyAgent(proxyUrl);
+      options2.agent = new HttpsProxyAgent(proxyUrl);
     }
     const results = await Promise.all(
       paths.map(async (path13) => {
-        const response = await fetch(`${baseUrl}/registry/${path13}`, options);
+        const response = await fetch(`${baseUrl}/registry/${path13}`, options2);
         return await response.json();
       })
     );
@@ -5485,7 +5771,7 @@ async function fetchRegistry(paths) {
   }
 }
 
-// node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.15/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.15/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -5567,7 +5853,7 @@ function encodeInteger(buf, pos2, state, segment, j) {
   return pos2;
 }
 
-// node_modules/.pnpm/magic-string@0.30.2/node_modules/magic-string/dist/magic-string.es.mjs
+// ../../node_modules/.pnpm/magic-string@0.30.8/node_modules/magic-string/dist/magic-string.es.mjs
 var BitSet = class {
   constructor(arg) {
     this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
@@ -5642,6 +5928,15 @@ var Chunk = class {
   prependRight(content) {
     this.intro = content + this.intro;
   }
+  reset() {
+    this.intro = "";
+    this.outro = "";
+    if (this.edited) {
+      this.content = this.original;
+      this.storeName = false;
+      this.edited = false;
+    }
+  }
   split(index) {
     const sliceIndex = index - this.start;
     const originalBefore = this.original.slice(0, sliceIndex);
@@ -5675,6 +5970,9 @@ var Chunk = class {
     if (trimmed.length) {
       if (trimmed !== this.content) {
         this.split(this.start + trimmed.length).edit("", void 0, true);
+        if (this.edited) {
+          this.edit(trimmed, this.storeName, true);
+        }
       }
       return true;
     } else {
@@ -5691,7 +5989,10 @@ var Chunk = class {
     const trimmed = this.content.replace(rx, "");
     if (trimmed.length) {
       if (trimmed !== this.content) {
-        this.split(this.end - trimmed.length);
+        const newChunk = this.split(this.end - trimmed.length);
+        if (this.edited) {
+          newChunk.edit(trimmed, this.storeName, true);
+        }
         this.edit("", void 0, true);
       }
       return true;
@@ -5704,8 +6005,8 @@ var Chunk = class {
   }
 };
 function getBtoa() {
-  if (typeof window !== "undefined" && typeof window.btoa === "function") {
-    return (str) => window.btoa(unescape(encodeURIComponent(str)));
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
   } else if (typeof Buffer === "function") {
     return (str) => Buffer.from(str, "utf-8").toString("base64");
   } else {
@@ -5804,15 +6105,31 @@ var Mappings = class {
   }
   addEdit(sourceIndex, content, loc, nameIndex) {
     if (content.length) {
+      const contentLengthMinusOne = content.length - 1;
+      let contentLineEnd = content.indexOf("\n", 0);
+      let previousContentLineEnd = -1;
+      while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+        const segment2 = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+        if (nameIndex >= 0) {
+          segment2.push(nameIndex);
+        }
+        this.rawSegments.push(segment2);
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        previousContentLineEnd = contentLineEnd;
+        contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+      }
       const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
       if (nameIndex >= 0) {
         segment.push(nameIndex);
       }
       this.rawSegments.push(segment);
+      this.advance(content.slice(previousContentLineEnd + 1));
     } else if (this.pending) {
       this.rawSegments.push(this.pending);
+      this.advance(content);
     }
-    this.advance(content);
     this.pending = null;
   }
   addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
@@ -5873,7 +6190,7 @@ var warned = {
   storeName: false
 };
 var MagicString = class {
-  constructor(string3, options = {}) {
+  constructor(string3, options2 = {}) {
     const chunk = new Chunk(0, string3.length, string3);
     Object.defineProperties(this, {
       original: { writable: true, value: string3 },
@@ -5884,12 +6201,12 @@ var MagicString = class {
       lastSearchedChunk: { writable: true, value: chunk },
       byStart: { writable: true, value: {} },
       byEnd: { writable: true, value: {} },
-      filename: { writable: true, value: options.filename },
-      indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+      filename: { writable: true, value: options2.filename },
+      indentExclusionRanges: { writable: true, value: options2.indentExclusionRanges },
       sourcemapLocations: { writable: true, value: new BitSet() },
       storedNames: { writable: true, value: {} },
       indentStr: { writable: true, value: void 0 },
-      ignoreList: { writable: true, value: options.ignoreList }
+      ignoreList: { writable: true, value: options2.ignoreList }
     });
     this.byStart[0] = chunk;
     this.byEnd[string3.length] = chunk;
@@ -5952,11 +6269,11 @@ var MagicString = class {
     cloned.outro = this.outro;
     return cloned;
   }
-  generateDecodedMap(options) {
-    options = options || {};
+  generateDecodedMap(options2) {
+    options2 = options2 || {};
     const sourceIndex = 0;
     const names = Object.keys(this.storedNames);
-    const mappings = new Mappings(options.hires);
+    const mappings = new Mappings(options2.hires);
     const locate = getLocator(this.original);
     if (this.intro) {
       mappings.advance(this.intro);
@@ -5979,18 +6296,18 @@ var MagicString = class {
         mappings.advance(chunk.outro);
     });
     return {
-      file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+      file: options2.file ? options2.file.split(/[/\\]/).pop() : void 0,
       sources: [
-        options.source ? getRelativePath(options.file || "", options.source) : options.file || ""
+        options2.source ? getRelativePath(options2.file || "", options2.source) : options2.file || ""
       ],
-      sourcesContent: options.includeContent ? [this.original] : void 0,
+      sourcesContent: options2.includeContent ? [this.original] : void 0,
       names,
       mappings: mappings.raw,
       x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
     };
   }
-  generateMap(options) {
-    return new SourceMap(this.generateDecodedMap(options));
+  generateMap(options2) {
+    return new SourceMap(this.generateDecodedMap(options2));
   }
   _ensureindentStr() {
     if (this.indentStr === void 0) {
@@ -6005,10 +6322,10 @@ var MagicString = class {
     this._ensureindentStr();
     return this.indentStr === null ? "	" : this.indentStr;
   }
-  indent(indentStr, options) {
+  indent(indentStr, options2) {
     const pattern = /^[^\r\n]/gm;
     if (isObject(indentStr)) {
-      options = indentStr;
+      options2 = indentStr;
       indentStr = void 0;
     }
     if (indentStr === void 0) {
@@ -6017,17 +6334,17 @@ var MagicString = class {
     }
     if (indentStr === "")
       return this;
-    options = options || {};
+    options2 = options2 || {};
     const isExcluded = {};
-    if (options.exclude) {
-      const exclusions = typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude;
+    if (options2.exclude) {
+      const exclusions = typeof options2.exclude[0] === "number" ? [options2.exclude] : options2.exclude;
       exclusions.forEach((exclusion) => {
         for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
           isExcluded[i] = true;
         }
       });
     }
-    let shouldIndentNextCharacter = options.indentStart !== false;
+    let shouldIndentNextCharacter = options2.indentStart !== false;
     const replacer = (match) => {
       if (shouldIndentNextCharacter)
         return `${indentStr}${match}`;
@@ -6132,11 +6449,11 @@ var MagicString = class {
       this.lastChunk = last;
     return this;
   }
-  overwrite(start, end, content, options) {
-    options = options || {};
-    return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+  overwrite(start, end, content, options2) {
+    options2 = options2 || {};
+    return this.update(start, end, content, { ...options2, overwrite: !options2.contentOnly });
   }
-  update(start, end, content, options) {
+  update(start, end, content, options2) {
     if (typeof content !== "string")
       throw new TypeError("replacement content must be a string");
     while (start < 0)
@@ -6151,17 +6468,17 @@ var MagicString = class {
       );
     this._split(start);
     this._split(end);
-    if (options === true) {
+    if (options2 === true) {
       if (!warned.storeName) {
         console.warn(
           "The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string"
         );
         warned.storeName = true;
       }
-      options = { storeName: true };
+      options2 = { storeName: true };
     }
-    const storeName = options !== void 0 ? options.storeName : false;
-    const overwrite = options !== void 0 ? options.overwrite : false;
+    const storeName = options2 !== void 0 ? options2.storeName : false;
+    const overwrite = options2 !== void 0 ? options2.overwrite : false;
     if (storeName) {
       const original = this.original.slice(start, end);
       Object.defineProperty(this.storedNames, original, {
@@ -6241,6 +6558,26 @@ var MagicString = class {
     }
     return this;
   }
+  reset(start, end) {
+    while (start < 0)
+      start += this.original.length;
+    while (end < 0)
+      end += this.original.length;
+    if (start === end)
+      return this;
+    if (start < 0 || end > this.original.length)
+      throw new Error("Character is out of bounds");
+    if (start > end)
+      throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.reset();
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
   lastChar() {
     if (this.outro.length)
       return this.outro[this.outro.length - 1];
@@ -6529,7 +6866,7 @@ var MagicString = class {
 // src/utils/transformers.ts
 function transformImports(content, config) {
   const s = new MagicString(content);
-  s.replaceAll(/@\/registry\/[^/]+/g, config.aliases.components);
+  s.replaceAll(/\$lib\/registry\/[^/]+/g, config.aliases.components);
   s.replaceAll(/\$lib\/utils/g, config.aliases.utils);
   return s.toString();
 }
@@ -6551,11 +6888,11 @@ var add = new Command().command("add").description("add components to your proje
   process.cwd()
 ).option("-p, --path <path>", "the path to add the component to.").action(async (components, opts) => {
   try {
-    const options = addOptionsSchema.parse({
+    const options2 = addOptionsSchema.parse({
       components,
       ...opts
     });
-    const cwd = path10.resolve(options.cwd);
+    const cwd = path10.resolve(options2.cwd);
     if (!existsSync2(cwd)) {
       logger.error(`The path ${cwd} does not exist. Please try again.`);
       process.exitCode = 1;
@@ -6571,17 +6908,17 @@ var add = new Command().command("add").description("add components to your proje
       process.exitCode = 1;
       return;
     }
-    const chosenProxy = options.proxy ?? getEnvProxy();
+    const chosenProxy = options2.proxy ?? getEnvProxy();
     if (chosenProxy) {
-      const isCustom = !!options.proxy;
+      const isCustom = !!options2.proxy;
       if (isCustom)
-        process.env.HTTP_PROXY = options.proxy;
+        process.env.HTTP_PROXY = options2.proxy;
       logger.warn(
         `You are using a ${isCustom ? "provided" : "system environment"} proxy: ${chalk3.green(chosenProxy)}`
       );
     }
     const registryIndex = await getRegistryIndex();
-    let selectedComponents = options.all ? registryIndex.map(({ name }) => name) : options.components;
+    let selectedComponents = options2.all ? registryIndex.map(({ name }) => name) : options2.components;
     if (!selectedComponents?.length) {
       const { components: components2 } = await prompts2({
         type: "multiselect",
@@ -6611,7 +6948,7 @@ var add = new Command().command("add").description("add components to your proje
     }
     logger.info(`Selected components:
 ${logger.highlight(selectedComponents)}`);
-    if (!options.yes) {
+    if (!options2.yes) {
       const { proceed } = await prompts2({
         type: "confirm",
         name: "proceed",
@@ -6631,7 +6968,7 @@ ${logger.highlight(selectedComponents)}`);
       const targetDir = await getItemTargetPath(
         config,
         item2,
-        options.path ? path10.resolve(cwd, options.path) : void 0
+        options2.path ? path10.resolve(cwd, options2.path) : void 0
       );
       if (!targetDir) {
         continue;
@@ -6646,7 +6983,7 @@ ${logger.highlight(selectedComponents)}`);
       const existingComponent = item2.files.filter((file) => {
         return existsSync2(path10.resolve(targetDir, item2.name, file.name));
       });
-      if (existingComponent.length && !options.overwrite) {
+      if (existingComponent.length && !options2.overwrite) {
         if (selectedComponents.includes(item2.name)) {
           logger.warn(
             `
@@ -6672,7 +7009,7 @@ Component ${logger.highlight(
         await fs6.writeFile(filePath, content);
       }
       if (item2.dependencies?.length) {
-        if (options.nodep) {
+        if (options2.nodep) {
           item2.dependencies.forEach((dep) => skippedDeps.add(dep));
           continue;
         }
@@ -6685,7 +7022,7 @@ Component ${logger.highlight(
     }
     logger.info("");
     logger.info("");
-    if (options.nodep) {
+    if (options2.nodep) {
       logger.warn(
         `Components have installed without dependencies, consider adding the following to your dependencies:
 - ${[
@@ -6893,14 +7230,14 @@ var init2 = new Command2().command("init").description("Configure your SvelteKit
   "-c, --cwd <cwd>",
   "the working directory. defaults to the current directory.",
   process.cwd()
-).action(async (options) => {
-  const cwd = path11.resolve(options.cwd);
+).action(async (options2) => {
+  const cwd = path11.resolve(options2.cwd);
   logger.warn("This command assumes a SvelteKit project with Tailwind CSS.");
   logger.warn(
     "If you don't have these, follow the manual steps at https://shadcn-svelte.com/docs/installation."
   );
   logger.warn("");
-  if (!options.yes) {
+  if (!options2.yes) {
     const { proceed } = await prompts3([
       {
         type: "confirm",
@@ -6921,7 +7258,7 @@ var init2 = new Command2().command("init").description("Configure your SvelteKit
       return;
     }
     const existingConfig = await getConfig2(cwd);
-    const config = await promptForConfig(cwd, existingConfig, options.yes);
+    const config = await promptForConfig(cwd, existingConfig, options2.yes);
     await runInit(cwd, config);
     logger.info("");
     logger.info(`${chalk4.green("Success!")} Project initialization completed.`);
@@ -6936,7 +7273,7 @@ async function promptForConfig(cwd, defaultConfig = null, skip = false) {
   const highlight = logger.highlight;
   const styles2 = await getRegistryStyles();
   const baseColors = await getRegistryBaseColors();
-  const options = await prompts3([
+  const options2 = await prompts3([
     {
       type: "toggle",
       name: "typescript",
@@ -7006,16 +7343,16 @@ async function promptForConfig(cwd, defaultConfig = null, skip = false) {
   ]);
   const config = rawConfigSchema.parse({
     $schema: "https://shadcn-svelte.com/schema.json",
-    style: options.style,
-    typescript: options.typescript,
+    style: options2.style,
+    typescript: options2.typescript,
     tailwind: {
-      config: options.tailwindConfig,
-      css: options.tailwindCss,
-      baseColor: options.tailwindBaseColor
+      config: options2.tailwindConfig,
+      css: options2.tailwindCss,
+      baseColor: options2.tailwindBaseColor
     },
     aliases: {
-      utils: options.utils,
-      components: options.components
+      utils: options2.utils,
+      components: options2.components
     }
   });
   if (!skip) {
@@ -7104,12 +7441,12 @@ var update = new Command3().command("update").description("update components in
   logger.warn("Make sure you have committed your changes before proceeding.");
   logger.warn("");
   try {
-    const options = updateOptionsSchema.parse({
+    const options2 = updateOptionsSchema.parse({
       components: comps,
       ...opts
     });
-    const components = options.components;
-    const cwd = path12.resolve(options.cwd);
+    const components = options2.components;
+    const cwd = path12.resolve(options2.cwd);
     if (!existsSync4(cwd)) {
       logger.error(`The path ${cwd} does not exist. Please try again.`);
       process.exitCode = 1;
@@ -7149,7 +7486,7 @@ var update = new Command3().command("update").description("update components in
       type: "components:ui",
       files: []
     });
-    let selectedComponents = options.all ? existingComponents : [];
+    let selectedComponents = options2.all ? existingComponents : [];
     if (!selectedComponents.length && components !== void 0) {
       selectedComponents = existingComponents.filter(
         (component) => components.includes(component.name)
@@ -7235,7 +7572,7 @@ The ${logger.highlight(
         files2.map((file) => chalk5.white(`- ${path12.relative(cwd, file)}`)).join("\n")
       );
     }
-    if (Object.keys(componentsToRemove)) {
+    if (Object.keys(componentsToRemove).length > 0) {
       logger.warn("\nYou may want to remove them.");
     }
   } catch (e) {