create-vuetify 2.3.1 → 2.4.0

package/dist/index.mjs

@@ -1,11 +1,11 @@
 // src/index.ts
-import { dirname as dirname2, join as join2, resolve as resolve3 } from "path";
+import { dirname as dirname3, join as join3, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 import { mkdirSync as mkdirSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
 
 // src/utils/prompts.ts
-import { resolve, join } from "path";
-import { existsSync, readdirSync } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import { existsSync as existsSync2, readdirSync } from "fs";
 
 // src/utils/presets.ts
 var defaultContext = {
@@ -34,6 +34,932 @@ var presets = {
 // src/utils/prompts.ts
 import { red } from "kolorist";
 import prompts from "prompts";
+
+// node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var normalize = function(path4) {
+  if (path4.length === 0) {
+    return ".";
+  }
+  path4 = normalizeWindowsPath(path4);
+  const isUNCPath = path4.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path4);
+  const trailingSeparator = path4[path4.length - 1] === "/";
+  path4 = normalizeString(path4, !isPathAbsolute);
+  if (path4.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path4 += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path4)) {
+    path4 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path4}`;
+    }
+    return `//${path4}`;
+  }
+  return isPathAbsolute && !isAbsolute(path4) ? `/${path4}` : path4;
+};
+var join = function(...segments) {
+  let path4 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path4.length > 0) {
+      const pathTrailing = path4[path4.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path4 += seg.slice(1);
+      } else {
+        path4 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path4 += seg;
+    }
+  }
+  return normalize(path4);
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path4 = index >= 0 ? arguments_[index] : cwd();
+    if (!path4 || path4.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path4}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path4);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path4, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path4.length; ++index) {
+    if (index < path4.length) {
+      char = path4[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path4.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path4.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+
+// node_modules/.pnpm/tinyexec@0.3.2/node_modules/tinyexec/dist/main.js
+import { createRequire as __tinyexec_cr } from "node:module";
+import { spawn as de } from "child_process";
+import { normalize as fe } from "path";
+import { cwd as he } from "process";
+import {
+  delimiter as N,
+  resolve as qt,
+  dirname as It
+} from "path";
+import { PassThrough as zt } from "stream";
+import me from "readline";
+var require2 = __tinyexec_cr(import.meta.url);
+var St = Object.create;
+var $ = Object.defineProperty;
+var kt = Object.getOwnPropertyDescriptor;
+var Tt = Object.getOwnPropertyNames;
+var At = Object.getPrototypeOf;
+var Rt = Object.prototype.hasOwnProperty;
+var h = /* @__PURE__ */ ((t) => typeof require2 < "u" ? require2 : typeof Proxy < "u" ? new Proxy(t, {
+  get: (e, n) => (typeof require2 < "u" ? require2 : e)[n]
+}) : t)(function(t) {
+  if (typeof require2 < "u") return require2.apply(this, arguments);
+  throw Error('Dynamic require of "' + t + '" is not supported');
+});
+var l = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports);
+var $t = (t, e, n, r) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let s of Tt(e))
+      !Rt.call(t, s) && s !== n && $(t, s, { get: () => e[s], enumerable: !(r = kt(e, s)) || r.enumerable });
+  return t;
+};
+var Nt = (t, e, n) => (n = t != null ? St(At(t)) : {}, $t(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  e || !t || !t.__esModule ? $(n, "default", { value: t, enumerable: true }) : n,
+  t
+));
+var W = l((Se, H) => {
+  "use strict";
+  H.exports = z;
+  z.sync = Wt;
+  var j = h("fs");
+  function Ht(t, e) {
+    var n = e.pathExt !== void 0 ? e.pathExt : process.env.PATHEXT;
+    if (!n || (n = n.split(";"), n.indexOf("") !== -1))
+      return true;
+    for (var r = 0; r < n.length; r++) {
+      var s = n[r].toLowerCase();
+      if (s && t.substr(-s.length).toLowerCase() === s)
+        return true;
+    }
+    return false;
+  }
+  function F(t, e, n) {
+    return !t.isSymbolicLink() && !t.isFile() ? false : Ht(e, n);
+  }
+  function z(t, e, n) {
+    j.stat(t, function(r, s) {
+      n(r, r ? false : F(s, t, e));
+    });
+  }
+  function Wt(t, e) {
+    return F(j.statSync(t), t, e);
+  }
+});
+var X = l((ke, B) => {
+  "use strict";
+  B.exports = K;
+  K.sync = Dt;
+  var D = h("fs");
+  function K(t, e, n) {
+    D.stat(t, function(r, s) {
+      n(r, r ? false : M(s, e));
+    });
+  }
+  function Dt(t, e) {
+    return M(D.statSync(t), e);
+  }
+  function M(t, e) {
+    return t.isFile() && Kt(t, e);
+  }
+  function Kt(t, e) {
+    var n = t.mode, r = t.uid, s = t.gid, o = e.uid !== void 0 ? e.uid : process.getuid && process.getuid(), i = e.gid !== void 0 ? e.gid : process.getgid && process.getgid(), a = parseInt("100", 8), c = parseInt("010", 8), u = parseInt("001", 8), f = a | c, p = n & u || n & c && s === i || n & a && r === o || n & f && o === 0;
+    return p;
+  }
+});
+var U = l((Ae, G) => {
+  "use strict";
+  var Te = h("fs"), v;
+  process.platform === "win32" || global.TESTING_WINDOWS ? v = W() : v = X();
+  G.exports = y;
+  y.sync = Mt;
+  function y(t, e, n) {
+    if (typeof e == "function" && (n = e, e = {}), !n) {
+      if (typeof Promise != "function")
+        throw new TypeError("callback not provided");
+      return new Promise(function(r, s) {
+        y(t, e || {}, function(o, i) {
+          o ? s(o) : r(i);
+        });
+      });
+    }
+    v(t, e || {}, function(r, s) {
+      r && (r.code === "EACCES" || e && e.ignoreErrors) && (r = null, s = false), n(r, s);
+    });
+  }
+  function Mt(t, e) {
+    try {
+      return v.sync(t, e || {});
+    } catch (n) {
+      if (e && e.ignoreErrors || n.code === "EACCES")
+        return false;
+      throw n;
+    }
+  }
+});
+var et = l((Re, tt) => {
+  "use strict";
+  var g = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys", Y = h("path"), Bt = g ? ";" : ":", V = U(), J = (t) => Object.assign(new Error(`not found: ${t}`), { code: "ENOENT" }), Q = (t, e) => {
+    let n = e.colon || Bt, r = t.match(/\//) || g && t.match(/\\/) ? [""] : [
+      // windows always checks the cwd first
+      ...g ? [process.cwd()] : [],
+      ...(e.path || process.env.PATH || /* istanbul ignore next: very unusual */
+      "").split(n)
+    ], s = g ? e.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "", o = g ? s.split(n) : [""];
+    return g && t.indexOf(".") !== -1 && o[0] !== "" && o.unshift(""), {
+      pathEnv: r,
+      pathExt: o,
+      pathExtExe: s
+    };
+  }, Z = (t, e, n) => {
+    typeof e == "function" && (n = e, e = {}), e || (e = {});
+    let { pathEnv: r, pathExt: s, pathExtExe: o } = Q(t, e), i = [], a = (u) => new Promise((f, p) => {
+      if (u === r.length)
+        return e.all && i.length ? f(i) : p(J(t));
+      let d = r[u], w = /^".*"$/.test(d) ? d.slice(1, -1) : d, m = Y.join(w, t), b = !w && /^\.[\\\/]/.test(t) ? t.slice(0, 2) + m : m;
+      f(c(b, u, 0));
+    }), c = (u, f, p) => new Promise((d, w) => {
+      if (p === s.length)
+        return d(a(f + 1));
+      let m = s[p];
+      V(u + m, { pathExt: o }, (b, Ot) => {
+        if (!b && Ot)
+          if (e.all)
+            i.push(u + m);
+          else
+            return d(u + m);
+        return d(c(u, f, p + 1));
+      });
+    });
+    return n ? a(0).then((u) => n(null, u), n) : a(0);
+  }, Xt = (t, e) => {
+    e = e || {};
+    let { pathEnv: n, pathExt: r, pathExtExe: s } = Q(t, e), o = [];
+    for (let i = 0; i < n.length; i++) {
+      let a = n[i], c = /^".*"$/.test(a) ? a.slice(1, -1) : a, u = Y.join(c, t), f = !c && /^\.[\\\/]/.test(t) ? t.slice(0, 2) + u : u;
+      for (let p = 0; p < r.length; p++) {
+        let d = f + r[p];
+        try {
+          if (V.sync(d, { pathExt: s }))
+            if (e.all)
+              o.push(d);
+            else
+              return d;
+        } catch {
+        }
+      }
+    }
+    if (e.all && o.length)
+      return o;
+    if (e.nothrow)
+      return null;
+    throw J(t);
+  };
+  tt.exports = Z;
+  Z.sync = Xt;
+});
+var rt = l(($e, _) => {
+  "use strict";
+  var nt = (t = {}) => {
+    let e = t.env || process.env;
+    return (t.platform || process.platform) !== "win32" ? "PATH" : Object.keys(e).reverse().find((r) => r.toUpperCase() === "PATH") || "Path";
+  };
+  _.exports = nt;
+  _.exports.default = nt;
+});
+var ct = l((Ne, it) => {
+  "use strict";
+  var st = h("path"), Gt = et(), Ut = rt();
+  function ot(t, e) {
+    let n = t.options.env || process.env, r = process.cwd(), s = t.options.cwd != null, o = s && process.chdir !== void 0 && !process.chdir.disabled;
+    if (o)
+      try {
+        process.chdir(t.options.cwd);
+      } catch {
+      }
+    let i;
+    try {
+      i = Gt.sync(t.command, {
+        path: n[Ut({ env: n })],
+        pathExt: e ? st.delimiter : void 0
+      });
+    } catch {
+    } finally {
+      o && process.chdir(r);
+    }
+    return i && (i = st.resolve(s ? t.options.cwd : "", i)), i;
+  }
+  function Yt(t) {
+    return ot(t) || ot(t, true);
+  }
+  it.exports = Yt;
+});
+var ut = l((qe, P) => {
+  "use strict";
+  var C = /([()\][%!^"`<>&|;, *?])/g;
+  function Vt(t) {
+    return t = t.replace(C, "^$1"), t;
+  }
+  function Jt(t, e) {
+    return t = `${t}`, t = t.replace(/(\\*)"/g, '$1$1\\"'), t = t.replace(/(\\*)$/, "$1$1"), t = `"${t}"`, t = t.replace(C, "^$1"), e && (t = t.replace(C, "^$1")), t;
+  }
+  P.exports.command = Vt;
+  P.exports.argument = Jt;
+});
+var lt = l((Ie, at) => {
+  "use strict";
+  at.exports = /^#!(.*)/;
+});
+var dt = l((Le, pt) => {
+  "use strict";
+  var Qt = lt();
+  pt.exports = (t = "") => {
+    let e = t.match(Qt);
+    if (!e)
+      return null;
+    let [n, r] = e[0].replace(/#! ?/, "").split(" "), s = n.split("/").pop();
+    return s === "env" ? r : r ? `${s} ${r}` : s;
+  };
+});
+var ht = l((je, ft) => {
+  "use strict";
+  var O = h("fs"), Zt = dt();
+  function te(t) {
+    let n = Buffer.alloc(150), r;
+    try {
+      r = O.openSync(t, "r"), O.readSync(r, n, 0, 150, 0), O.closeSync(r);
+    } catch {
+    }
+    return Zt(n.toString());
+  }
+  ft.exports = te;
+});
+var wt = l((Fe, Et) => {
+  "use strict";
+  var ee = h("path"), mt = ct(), gt = ut(), ne = ht(), re = process.platform === "win32", se = /\.(?:com|exe)$/i, oe = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function ie(t) {
+    t.file = mt(t);
+    let e = t.file && ne(t.file);
+    return e ? (t.args.unshift(t.file), t.command = e, mt(t)) : t.file;
+  }
+  function ce(t) {
+    if (!re)
+      return t;
+    let e = ie(t), n = !se.test(e);
+    if (t.options.forceShell || n) {
+      let r = oe.test(e);
+      t.command = ee.normalize(t.command), t.command = gt.command(t.command), t.args = t.args.map((o) => gt.argument(o, r));
+      let s = [t.command].concat(t.args).join(" ");
+      t.args = ["/d", "/s", "/c", `"${s}"`], t.command = process.env.comspec || "cmd.exe", t.options.windowsVerbatimArguments = true;
+    }
+    return t;
+  }
+  function ue(t, e, n) {
+    e && !Array.isArray(e) && (n = e, e = null), e = e ? e.slice(0) : [], n = Object.assign({}, n);
+    let r = {
+      command: t,
+      args: e,
+      options: n,
+      file: void 0,
+      original: {
+        command: t,
+        args: e
+      }
+    };
+    return n.shell ? r : ce(r);
+  }
+  Et.exports = ue;
+});
+var bt = l((ze, vt) => {
+  "use strict";
+  var S = process.platform === "win32";
+  function k(t, e) {
+    return Object.assign(new Error(`${e} ${t.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${e} ${t.command}`,
+      path: t.command,
+      spawnargs: t.args
+    });
+  }
+  function ae(t, e) {
+    if (!S)
+      return;
+    let n = t.emit;
+    t.emit = function(r, s) {
+      if (r === "exit") {
+        let o = xt(s, e, "spawn");
+        if (o)
+          return n.call(t, "error", o);
+      }
+      return n.apply(t, arguments);
+    };
+  }
+  function xt(t, e) {
+    return S && t === 1 && !e.file ? k(e.original, "spawn") : null;
+  }
+  function le(t, e) {
+    return S && t === 1 && !e.file ? k(e.original, "spawnSync") : null;
+  }
+  vt.exports = {
+    hookChildProcess: ae,
+    verifyENOENT: xt,
+    verifyENOENTSync: le,
+    notFoundError: k
+  };
+});
+var Ct = l((He, E) => {
+  "use strict";
+  var yt = h("child_process"), T = wt(), A = bt();
+  function _t(t, e, n) {
+    let r = T(t, e, n), s = yt.spawn(r.command, r.args, r.options);
+    return A.hookChildProcess(s, r), s;
+  }
+  function pe(t, e, n) {
+    let r = T(t, e, n), s = yt.spawnSync(r.command, r.args, r.options);
+    return s.error = s.error || A.verifyENOENTSync(s.status, r), s;
+  }
+  E.exports = _t;
+  E.exports.spawn = _t;
+  E.exports.sync = pe;
+  E.exports._parse = T;
+  E.exports._enoent = A;
+});
+var Lt = /^path$/i;
+var q = { key: "PATH", value: "" };
+function jt(t) {
+  for (let e in t) {
+    if (!Object.prototype.hasOwnProperty.call(t, e) || !Lt.test(e))
+      continue;
+    let n = t[e];
+    return n ? { key: e, value: n } : q;
+  }
+  return q;
+}
+function Ft(t, e) {
+  let n = e.value.split(N), r = t, s;
+  do
+    n.push(qt(r, "node_modules", ".bin")), s = r, r = It(r);
+  while (r !== s);
+  return { key: e.key, value: n.join(N) };
+}
+function I(t, e) {
+  let n = {
+    ...process.env,
+    ...e
+  }, r = Ft(t, jt(n));
+  return n[r.key] = r.value, n;
+}
+var L = (t) => {
+  let e = t.length, n = new zt(), r = () => {
+    --e === 0 && n.emit("end");
+  };
+  for (let s of t)
+    s.pipe(n, { end: false }), s.on("end", r);
+  return n;
+};
+var Pt = Nt(Ct(), 1);
+var x = class extends Error {
+  result;
+  output;
+  get exitCode() {
+    if (this.result.exitCode !== null)
+      return this.result.exitCode;
+  }
+  constructor(e, n) {
+    super(`Process exited with non-zero status (${e.exitCode})`), this.result = e, this.output = n;
+  }
+};
+var ge = {
+  timeout: void 0,
+  persist: false
+};
+var Ee = {
+  windowsHide: true
+};
+function we(t, e) {
+  return {
+    command: fe(t),
+    args: e ?? []
+  };
+}
+function xe(t) {
+  let e = new AbortController();
+  for (let n of t) {
+    if (n.aborted)
+      return e.abort(), n;
+    let r = () => {
+      e.abort(n.reason);
+    };
+    n.addEventListener("abort", r, {
+      signal: e.signal
+    });
+  }
+  return e.signal;
+}
+var R = class {
+  _process;
+  _aborted = false;
+  _options;
+  _command;
+  _args;
+  _resolveClose;
+  _processClosed;
+  _thrownError;
+  get process() {
+    return this._process;
+  }
+  get pid() {
+    return this._process?.pid;
+  }
+  get exitCode() {
+    if (this._process && this._process.exitCode !== null)
+      return this._process.exitCode;
+  }
+  constructor(e, n, r) {
+    this._options = {
+      ...ge,
+      ...r
+    }, this._command = e, this._args = n ?? [], this._processClosed = new Promise((s) => {
+      this._resolveClose = s;
+    });
+  }
+  kill(e) {
+    return this._process?.kill(e) === true;
+  }
+  get aborted() {
+    return this._aborted;
+  }
+  get killed() {
+    return this._process?.killed === true;
+  }
+  pipe(e, n, r) {
+    return be(e, n, {
+      ...r,
+      stdin: this
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    let e = this._process;
+    if (!e)
+      return;
+    let n = [];
+    this._streamErr && n.push(this._streamErr), this._streamOut && n.push(this._streamOut);
+    let r = L(n), s = me.createInterface({
+      input: r
+    });
+    for await (let o of s)
+      yield o.toString();
+    if (await this._processClosed, e.removeAllListeners(), this._thrownError)
+      throw this._thrownError;
+    if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0)
+      throw new x(this);
+  }
+  async _waitForOutput() {
+    let e = this._process;
+    if (!e)
+      throw new Error("No process was started");
+    let n = "", r = "";
+    if (this._streamOut)
+      for await (let o of this._streamOut)
+        r += o.toString();
+    if (this._streamErr)
+      for await (let o of this._streamErr)
+        n += o.toString();
+    if (await this._processClosed, this._options?.stdin && await this._options.stdin, e.removeAllListeners(), this._thrownError)
+      throw this._thrownError;
+    let s = {
+      stderr: n,
+      stdout: r,
+      exitCode: this.exitCode
+    };
+    if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0)
+      throw new x(this, s);
+    return s;
+  }
+  then(e, n) {
+    return this._waitForOutput().then(e, n);
+  }
+  _streamOut;
+  _streamErr;
+  spawn() {
+    let e = he(), n = this._options, r = {
+      ...Ee,
+      ...n.nodeOptions
+    }, s = [];
+    this._resetState(), n.timeout !== void 0 && s.push(AbortSignal.timeout(n.timeout)), n.signal !== void 0 && s.push(n.signal), n.persist === true && (r.detached = true), s.length > 0 && (r.signal = xe(s)), r.env = I(e, r.env);
+    let { command: o, args: i } = we(this._command, this._args), a = (0, Pt._parse)(o, i, r), c = de(
+      a.command,
+      a.args,
+      a.options
+    );
+    if (c.stderr && (this._streamErr = c.stderr), c.stdout && (this._streamOut = c.stdout), this._process = c, c.once("error", this._onError), c.once("close", this._onClose), n.stdin !== void 0 && c.stdin && n.stdin.process) {
+      let { stdout: u } = n.stdin.process;
+      u && u.pipe(c.stdin);
+    }
+  }
+  _resetState() {
+    this._aborted = false, this._processClosed = new Promise((e) => {
+      this._resolveClose = e;
+    }), this._thrownError = void 0;
+  }
+  _onError = (e) => {
+    if (e.name === "AbortError" && (!(e.cause instanceof Error) || e.cause.name !== "TimeoutError")) {
+      this._aborted = true;
+      return;
+    }
+    this._thrownError = e;
+  };
+  _onClose = () => {
+    this._resolveClose && this._resolveClose();
+  };
+};
+var ve = (t, e, n) => {
+  let r = new R(t, e, n);
+  return r.spawn(), r;
+};
+var be = ve;
+
+// node_modules/.pnpm/nypm@0.6.0/node_modules/nypm/dist/shared/nypm.Bcw9TJOu.mjs
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+async function findup(cwd2, match, options = {}) {
+  const segments = normalize(cwd2).split("/");
+  while (segments.length > 0) {
+    const path4 = segments.join("/") || "/";
+    const result = await match(path4);
+    if (result || !options.includeParentDirs) {
+      return result;
+    }
+    segments.pop();
+  }
+}
+function cached(fn) {
+  let v;
+  return () => {
+    if (v === void 0) {
+      v = fn().then((r) => {
+        v = r;
+        return v;
+      });
+    }
+    return v;
+  };
+}
+var hasCorepack = cached(async () => {
+  if (globalThis.process?.versions?.webcontainer) {
+    return false;
+  }
+  try {
+    const { exitCode } = await ve("corepack", ["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+});
+async function executeCommand(command, args, options = {}) {
+  const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+  const { exitCode, stdout, stderr } = await ve(xArgs[0], xArgs[1], {
+    nodeOptions: {
+      cwd: resolve(options.cwd || process.cwd()),
+      stdio: options.silent ? "pipe" : "inherit"
+    }
+  });
+  if (exitCode !== 0) {
+    throw new Error(
+      `\`${xArgs.flat().join(" ")}\` failed.${options.silent ? ["", stdout, stderr].join("\n") : ""}`
+    );
+  }
+}
+var NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
+async function resolveOperationOptions(options = {}) {
+  const cwd2 = options.cwd || process.cwd();
+  const packageManager2 = (typeof options.packageManager === "string" ? packageManagers.find((pm) => pm.name === options.packageManager) : options.packageManager) || await detectPackageManager(options.cwd || process.cwd());
+  if (!packageManager2) {
+    throw new Error(NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG);
+  }
+  return {
+    cwd: cwd2,
+    silent: options.silent ?? false,
+    packageManager: packageManager2,
+    dev: options.dev ?? false,
+    workspace: options.workspace,
+    global: options.global ?? false
+  };
+}
+function parsePackageManagerField(packageManager2) {
+  const [name, _version] = (packageManager2 || "").split("@");
+  const [version, buildMeta] = _version?.split("+") || [];
+  if (name && name !== "-" && /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name)) {
+    return { name, version, buildMeta };
+  }
+  const sanitized = name.replace(/\W+/g, "");
+  const warnings = [
+    `Abnormal characters found in \`packageManager\` field, sanitizing from \`${name}\` to \`${sanitized}\``
+  ];
+  return {
+    name: sanitized,
+    version,
+    buildMeta,
+    warnings
+  };
+}
+var packageManagers = [
+  {
+    name: "npm",
+    command: "npm",
+    lockFile: "package-lock.json"
+  },
+  {
+    name: "pnpm",
+    command: "pnpm",
+    lockFile: "pnpm-lock.yaml",
+    files: ["pnpm-workspace.yaml"]
+  },
+  {
+    name: "bun",
+    command: "bun",
+    lockFile: ["bun.lockb", "bun.lock"]
+  },
+  {
+    name: "yarn",
+    command: "yarn",
+    lockFile: "yarn.lock",
+    files: [".yarnrc.yml"]
+  },
+  {
+    name: "deno",
+    command: "deno",
+    lockFile: "deno.lock",
+    files: ["deno.json"]
+  }
+];
+async function detectPackageManager(cwd2, options = {}) {
+  const detected = await findup(
+    resolve(cwd2 || "."),
+    async (path4) => {
+      if (!options.ignorePackageJSON) {
+        const packageJSONPath = join(path4, "package.json");
+        if (existsSync(packageJSONPath)) {
+          const packageJSON = JSON.parse(
+            await readFile(packageJSONPath, "utf8")
+          );
+          if (packageJSON?.packageManager) {
+            const {
+              name,
+              version = "0.0.0",
+              buildMeta,
+              warnings
+            } = parsePackageManagerField(packageJSON.packageManager);
+            if (name) {
+              const majorVersion = version.split(".")[0];
+              const packageManager2 = packageManagers.find(
+                (pm) => pm.name === name && pm.majorVersion === majorVersion
+              ) || packageManagers.find((pm) => pm.name === name);
+              return {
+                name,
+                command: name,
+                version,
+                majorVersion,
+                buildMeta,
+                warnings,
+                files: packageManager2?.files,
+                lockFile: packageManager2?.lockFile
+              };
+            }
+          }
+        }
+        const denoJSONPath = join(path4, "deno.json");
+        if (existsSync(denoJSONPath)) {
+          return packageManagers.find((pm) => pm.name === "deno");
+        }
+      }
+      if (!options.ignoreLockFile) {
+        for (const packageManager2 of packageManagers) {
+          const detectionsFiles = [
+            packageManager2.lockFile,
+            packageManager2.files
+          ].flat().filter(Boolean);
+          if (detectionsFiles.some((file) => existsSync(resolve(path4, file)))) {
+            return {
+              ...packageManager2
+            };
+          }
+        }
+      }
+    },
+    {
+      includeParentDirs: options.includeParentDirs ?? true
+    }
+  );
+  if (!detected && !options.ignoreArgv) {
+    const scriptArg = process.argv[1];
+    if (scriptArg) {
+      for (const packageManager2 of packageManagers) {
+        const re = new RegExp(`[/\\\\]\\.?${packageManager2.command}`);
+        if (re.test(scriptArg)) {
+          return packageManager2;
+        }
+      }
+    }
+  }
+  return detected;
+}
+async function installDependencies(options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const pmToFrozenLockfileInstallCommand = {
+    npm: ["ci"],
+    yarn: ["install", "--immutable"],
+    bun: ["install", "--frozen-lockfile"],
+    pnpm: ["install", "--frozen-lockfile"],
+    deno: ["install", "--frozen"]
+  };
+  const commandArgs = options.frozenLockFile ? pmToFrozenLockfileInstallCommand[resolvedOptions.packageManager.name] : ["install"];
+  await executeCommand(resolvedOptions.packageManager.command, commandArgs, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+}
+
+// src/utils/cli/pnpmIgnored.ts
+import { execSync } from "node:child_process";
+function pnpmIgnored(root) {
+  const pnpmVersion = execSync(`cd ${root} && pnpm -v`, { encoding: "utf8" }).trim();
+  const [major] = pnpmVersion.split(".").map(Number);
+  if (major && major >= 10) {
+    const detect2 = execSync(`cd ${root} && pnpm ignored-builds`, { encoding: "utf8" });
+    if (detect2.startsWith("Automatically ignored builds during installation:\n  None")) return;
+    return detect2;
+  }
+}
+
+// src/utils/installDependencies.ts
+var userAgent = process.env.npm_config_user_agent ?? "";
+var packageManager = /bun/.test(userAgent) ? "bun" : "pnpm";
+async function installDependencies2(root = process.cwd(), manager = packageManager) {
+  await installDependencies({
+    packageManager: manager,
+    cwd: root,
+    silent: true
+  }).catch(() => {
+    console.error(
+      `Failed to install dependencies using ${manager}.`
+    );
+  }).then(() => {
+    if (manager === "pnpm") {
+      const detect2 = pnpmIgnored(root);
+      if (detect2) console.warn(detect2);
+    }
+  });
+}
+
+// src/utils/prompts.ts
 import validate from "validate-npm-package-name";
 var promptOptions = {
   onCancel: () => {
@@ -54,9 +980,14 @@ var initPrompts = async (context) => {
       type: "text",
       message: "Project name:",
       initial: "vuetify-project",
+      format: (v) => v.trim(),
       validate: (v) => {
-        const { errors } = validate(String(v).trim());
-        return !(errors && errors.length) || `Package ${errors[0]}`;
+        const { errors, warnings, validForNewPackages: isValid } = validate(String(v).trim());
+        const error = isValid ? null : errors ? errors[0] : warnings[0];
+        if (!isValid) {
+          return `Package ${error}`;
+        }
+        return true;
       }
     },
     {
@@ -65,10 +996,16 @@ var initPrompts = async (context) => {
       inactive: "No",
       initial: false,
       type: (_, { projectName }) => {
-        const projectPath = join(context.cwd, projectName);
-        return !existsSync(projectPath) || readdirSync(projectPath).length === 0 ? null : "toggle";
+        const projectPath = join2(context.cwd, projectName);
+        return !existsSync2(projectPath) || readdirSync(projectPath).length === 0 ? null : "toggle";
+      },
+      onState(a) {
+        if (!a.value) {
+          console.error("\n\n", red("\u2716") + " Target directory exists and is not empty.");
+          process.exit(1);
+        }
       },
-      message: (prev) => `The project path: ${resolve(context.cwd, prev)} already exists, would you like to overwrite this directory?`
+      message: (prev) => `The project path: ${resolve2(context.cwd, prev)} already exists, would you like to overwrite this directory?`
     },
     {
       name: "usePreset",
@@ -102,11 +1039,11 @@ var initPrompts = async (context) => {
         return p.startsWith("nuxt-") ? null : "select";
       },
       message: "Would you like to install dependencies with yarn, npm, pnpm, or bun?",
-      initial: 0,
+      initial: packageManager === "bun" ? 3 : 0,
       choices: [
-        { title: "yarn", value: "yarn" },
-        { title: "npm", value: "npm" },
         { title: "pnpm", value: "pnpm" },
+        { title: "npm", value: "npm" },
+        { title: "yarn", value: "yarn" },
         { title: "bun", value: "bun" },
         { title: "none", value: null }
       ]
@@ -180,23 +1117,9 @@ var initPrompts = async (context) => {
 import { red as red2 } from "kolorist";
 import minimist from "minimist";
 
-// src/utils/installDependencies.ts
-import { spawnSync } from "child_process";
-function installDependencies(projectRoot, packageManager) {
-  const cmd = packageManager === "npm" ? "npm install" : packageManager === "yarn" ? "yarn" : packageManager === "bun" ? "bun install" : "pnpm install";
-  const spawn = spawnSync(cmd, {
-    cwd: projectRoot,
-    stdio: ["inherit", "inherit", "pipe"],
-    shell: true
-  });
-  if (spawn.error) {
-    throw spawn.error;
-  }
-}
-
 // src/utils/renderTemplate.ts
 import { copyFileSync, mkdirSync, readdirSync as readdirSync2, readFileSync, statSync, writeFileSync } from "fs";
-import { basename, dirname, resolve as resolve2 } from "path";
+import { basename as basename2, dirname as dirname2, resolve as resolve3 } from "path";
 
 // src/utils/deepMerge.ts
 var isObject = (v) => {
@@ -228,16 +1151,13 @@ function mergePkg(source, destination) {
 }
 function renderDirectory(source, destination) {
   mkdirSync(destination, { recursive: true });
-  readdirSync2(source).forEach((path4) => renderTemplate(resolve2(source, path4), resolve2(destination, path4)));
+  readdirSync2(source).forEach((path4) => renderTemplate(resolve3(source, path4), resolve3(destination, path4)));
 }
 function renderFile(source, destination) {
-  const filename = basename(source);
-  if (filename.startsWith("_"))
-    destination = resolve2(dirname(destination), filename.replace("_", "."));
-  if (filename === "package.json")
-    mergePkg(source, destination);
-  else
-    copyFileSync(source, destination);
+  const filename = basename2(source);
+  if (filename.startsWith("_")) destination = resolve3(dirname2(destination), filename.replace("_", "."));
+  if (filename === "package.json") mergePkg(source, destination);
+  else copyFileSync(source, destination);
 }
 function renderTemplate(source, destination) {
   if (statSync(source).isDirectory()) {
@@ -250,15 +1170,15 @@ function renderTemplate(source, destination) {
 // src/utils/nuxt/renderNuxtTemplate.ts
 import fs3 from "fs";
 import path3 from "path";
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 
 // src/utils/nuxt/utils.ts
 import process2 from "process";
 import path from "path";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 import fs from "fs";
 
-// node_modules/.pnpm/package-manager-detector@0.2.2/node_modules/package-manager-detector/dist/commands.mjs
+// node_modules/.pnpm/package-manager-detector@1.0.0/node_modules/package-manager-detector/dist/commands.mjs
 function npmRun(agent) {
   return (args) => {
     if (args.length > 1) {
@@ -268,11 +1188,30 @@ function npmRun(agent) {
     }
   };
 }
+function denoExecute() {
+  return (args) => {
+    return ["deno", "run", `npm:${args[0]}`, ...args.slice(1)];
+  };
+}
+var npm = {
+  "agent": ["npm", 0],
+  "run": npmRun("npm"),
+  "install": ["npm", "i", 0],
+  "frozen": ["npm", "ci", 0],
+  "global": ["npm", "i", "-g", 0],
+  "add": ["npm", "i", 0],
+  "upgrade": ["npm", "update", 0],
+  "upgrade-interactive": null,
+  "execute": ["npx", 0],
+  "execute-local": ["npx", 0],
+  "uninstall": ["npm", "uninstall", 0],
+  "global_uninstall": ["npm", "uninstall", "-g", 0]
+};
 var yarn = {
   "agent": ["yarn", 0],
   "run": ["yarn", "run", 0],
   "install": ["yarn", "install", 0],
-  "frozen": ["yarn", "install", "--frozen-lockfile"],
+  "frozen": ["yarn", "install", "--frozen-lockfile", 0],
   "global": ["yarn", "global", "add", 0],
   "add": ["yarn", "add", 0],
   "upgrade": ["yarn", "upgrade", 0],
@@ -282,11 +1221,22 @@ var yarn = {
   "uninstall": ["yarn", "remove", 0],
   "global_uninstall": ["yarn", "global", "remove", 0]
 };
+var yarnBerry = {
+  ...yarn,
+  "frozen": ["yarn", "install", "--immutable", 0],
+  "upgrade": ["yarn", "up", 0],
+  "upgrade-interactive": ["yarn", "up", "-i", 0],
+  "execute": ["yarn", "dlx", 0],
+  "execute-local": ["yarn", "exec", 0],
+  // Yarn 2+ removed 'global', see https://github.com/yarnpkg/berry/issues/821
+  "global": ["npm", "i", "-g", 0],
+  "global_uninstall": ["npm", "uninstall", "-g", 0]
+};
 var pnpm = {
   "agent": ["pnpm", 0],
   "run": ["pnpm", "run", 0],
   "install": ["pnpm", "i", 0],
-  "frozen": ["pnpm", "i", "--frozen-lockfile"],
+  "frozen": ["pnpm", "i", "--frozen-lockfile", 0],
   "global": ["pnpm", "add", "-g", 0],
   "add": ["pnpm", "add", 0],
   "upgrade": ["pnpm", "update", 0],
@@ -300,7 +1250,7 @@ var bun = {
   "agent": ["bun", 0],
   "run": ["bun", "run", 0],
   "install": ["bun", "install", 0],
-  "frozen": ["bun", "install", "--frozen-lockfile"],
+  "frozen": ["bun", "install", "--frozen-lockfile", 0],
   "global": ["bun", "add", "-g", 0],
   "add": ["bun", "add", 0],
   "upgrade": ["bun", "update", 0],
@@ -310,38 +1260,32 @@ var bun = {
   "uninstall": ["bun", "remove", 0],
   "global_uninstall": ["bun", "remove", "-g", 0]
 };
+var deno = {
+  "agent": ["deno", 0],
+  "run": ["deno", "task", 0],
+  "install": ["deno", "install", 0],
+  "frozen": ["deno", "install", "--frozen", 0],
+  "global": ["deno", "install", "-g", 0],
+  "add": ["deno", "add", 0],
+  "upgrade": ["deno", "outdated", "--update", 0],
+  "upgrade-interactive": ["deno", "outdated", "--update", 0],
+  "execute": denoExecute(),
+  "execute-local": ["deno", "task", "--eval", 0],
+  "uninstall": ["deno", "remove", 0],
+  "global_uninstall": ["deno", "uninstall", "-g", 0]
+};
 var COMMANDS = {
-  "npm": {
-    "agent": ["npm", 0],
-    "run": npmRun("npm"),
-    "install": ["npm", "i", 0],
-    "frozen": ["npm", "ci"],
-    "global": ["npm", "i", "-g", 0],
-    "add": ["npm", "i", 0],
-    "upgrade": ["npm", "update", 0],
-    "upgrade-interactive": null,
-    "execute": ["npx", 0],
-    "execute-local": ["npx", 0],
-    "uninstall": ["npm", "uninstall", 0],
-    "global_uninstall": ["npm", "uninstall", "-g", 0]
-  },
+  "npm": npm,
   "yarn": yarn,
-  "yarn@berry": {
-    ...yarn,
-    "frozen": ["yarn", "install", "--immutable"],
-    "upgrade": ["yarn", "up", 0],
-    "upgrade-interactive": ["yarn", "up", "-i", 0],
-    "execute": ["yarn", "dlx", 0],
-    "execute-local": ["yarn", "exec", 0],
-    "global": ["npm", "i", "-g", 0],
-    "global_uninstall": ["npm", "uninstall", "-g", 0]
-  },
+  "yarn@berry": yarnBerry,
   "pnpm": pnpm,
+  // pnpm v6.x or below
   "pnpm@6": {
     ...pnpm,
     run: npmRun("pnpm")
   },
-  "bun": bun
+  "bun": bun,
+  "deno": deno
 };
 function resolveCommand(agent, command, args) {
   const value = COMMANDS[agent][command];
@@ -363,10 +1307,10 @@ function constructCommand(value, args) {
 
 // src/utils/nuxt/utils.ts
 function detectPkgInfo() {
-  const userAgent = process2.env.npm_config_user_agent;
-  if (!userAgent)
+  const userAgent2 = process2.env.npm_config_user_agent;
+  if (!userAgent2)
     return void 0;
-  const pkgSpec = userAgent.split(" ")[0];
+  const pkgSpec = userAgent2.split(" ")[0];
   const pkgSpecArr = pkgSpec.split("/");
   return {
     name: pkgSpecArr[0],
@@ -389,7 +1333,7 @@ function addPackageObject(key, entry, pkg, sort = true) {
     pkg[key][k] = v;
   });
 }
-function runCommand(pmDetection, command, args, cwd) {
+function runCommand(pmDetection, command, args, cwd2) {
   let runCommand2 = "npm";
   let runArgs = [command];
   if (pmDetection) {
@@ -397,11 +1341,11 @@ function runCommand(pmDetection, command, args, cwd) {
     runCommand2 = prepare.command;
     runArgs = prepare.args;
   }
-  const run2 = spawnSync2(
+  const run2 = spawnSync(
     runCommand2,
     runArgs.filter(Boolean),
     {
-      cwd,
+      cwd: cwd2,
       stdio: ["inherit", "inherit", "pipe"],
       shell: true
     }
@@ -420,61 +1364,67 @@ function getPaths(rootPath, templateDir, v4) {
 
 // src/utils/nuxt/versions.ts
 var versions = {
-  "vuetify": "^3.7.3",
+  "vuetify": "^3.8.1",
   "typescript": "^5.6.3",
   "vue-tsc": "^2.1.6",
-  "sass-embedded": "^1.80.3",
-  "@vuetify/loader-shared": "^2.0.3",
-  "vite-plugin-vuetify": "^2.0.4",
-  "vuetify-nuxt-module": "^0.18.3",
+  "sass-embedded": "^1.86.3",
+  "@vuetify/loader-shared": "^2.1.0",
+  "vite-plugin-vuetify": "^2.1.1",
+  "vuetify-nuxt-module": "^0.18.6",
   "upath": "^2.0.1",
   "@mdi/font": "^7.4.47",
-  "@nuxt/fonts": "^0.10.0"
+  "@nuxt/fonts": "^0.11.1"
 };
 
-// node_modules/.pnpm/package-manager-detector@0.2.2/node_modules/package-manager-detector/dist/constants.mjs
+// node_modules/.pnpm/package-manager-detector@1.0.0/node_modules/package-manager-detector/dist/constants.mjs
 var AGENTS = [
   "npm",
   "yarn",
   "yarn@berry",
   "pnpm",
   "pnpm@6",
-  "bun"
+  "bun",
+  "deno"
 ];
 var LOCKS = {
+  "bun.lock": "bun",
   "bun.lockb": "bun",
+  "deno.lock": "deno",
   "pnpm-lock.yaml": "pnpm",
   "yarn.lock": "yarn",
   "package-lock.json": "npm",
   "npm-shrinkwrap.json": "npm"
 };
+var INSTALL_METADATA = {
+  "node_modules/.deno/": "deno",
+  "node_modules/.pnpm/": "pnpm",
+  "node_modules/.yarn-state.yml": "yarn",
+  // yarn v2+ (node-modules)
+  "node_modules/.yarn_integrity": "yarn",
+  // yarn v1
+  "node_modules/.package-lock.json": "npm",
+  ".pnp.cjs": "yarn",
+  // yarn v3+ (pnp)
+  ".pnp.js": "yarn",
+  // yarn v2 (pnp)
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
 
-// node_modules/.pnpm/package-manager-detector@0.2.2/node_modules/package-manager-detector/dist/detect.mjs
+// node_modules/.pnpm/package-manager-detector@1.0.0/node_modules/package-manager-detector/dist/detect.mjs
 import fs2 from "node:fs";
-import fsPromises from "node:fs/promises";
 import path2 from "node:path";
 import process3 from "node:process";
-async function detect(options = {}) {
-  const { cwd, onUnknown } = options;
-  for (const directory of lookup(cwd)) {
-    for (const lock of Object.keys(LOCKS)) {
-      if (await fileExists(path2.join(directory, lock))) {
-        const name = LOCKS[lock];
-        const result2 = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
-        if (result2)
-          return result2;
-        else
-          return { name, agent: name };
-      }
-    }
-    const result = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
-    if (result)
-      return result;
+function pathExists(path22, type) {
+  try {
+    const stat = fs2.statSync(path22);
+    return type === "file" ? stat.isFile() : stat.isDirectory();
+  } catch {
+    return false;
   }
-  return null;
 }
-function* lookup(cwd = process3.cwd()) {
-  let directory = path2.resolve(cwd);
+function* lookup(cwd2 = process3.cwd()) {
+  let directory = path2.resolve(cwd2);
   const { root } = path2.parse(directory);
   while (directory && directory !== root) {
     yield directory;
@@ -482,11 +1432,51 @@ function* lookup(cwd = process3.cwd()) {
   }
 }
 async function parsePackageJson(filepath, onUnknown) {
-  return !filepath || !await fileExists(filepath) ? null : handlePackageManager(filepath, onUnknown);
+  return !filepath || !pathExists(filepath, "file") ? null : await handlePackageManager(filepath, onUnknown);
 }
-function handlePackageManager(filepath, onUnknown) {
+async function detect(options = {}) {
+  const { cwd: cwd2, strategies = ["lockfile", "packageManager-field"], onUnknown } = options;
+  for (const directory of lookup(cwd2)) {
+    for (const strategy of strategies) {
+      switch (strategy) {
+        case "lockfile": {
+          for (const lock of Object.keys(LOCKS)) {
+            if (await pathExists(path2.join(directory, lock), "file")) {
+              const name = LOCKS[lock];
+              const result = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
+              if (result)
+                return result;
+              else
+                return { name, agent: name };
+            }
+          }
+          break;
+        }
+        case "packageManager-field": {
+          const result = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
+          if (result)
+            return result;
+          break;
+        }
+        case "install-metadata": {
+          for (const metadata of Object.keys(INSTALL_METADATA)) {
+            const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+            if (await pathExists(path2.join(directory, metadata), fileOrDir)) {
+              const name = INSTALL_METADATA[metadata];
+              const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+              return { name, agent };
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  return null;
+}
+async function handlePackageManager(filepath, onUnknown) {
   try {
-    const pkg = JSON.parse(fs2.readFileSync(filepath, "utf8"));
+    const pkg = JSON.parse(await fs2.promises.readFile(filepath, "utf8"));
     let agent;
     if (typeof pkg.packageManager === "string") {
       const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
@@ -509,15 +1499,8 @@ function handlePackageManager(filepath, onUnknown) {
   }
   return null;
 }
-async function fileExists(filePath) {
-  try {
-    const stats = await fsPromises.stat(filePath);
-    if (stats.isFile()) {
-      return true;
-    }
-  } catch {
-  }
-  return false;
+function isMetadataYarnClassic(metadataPath) {
+  return metadataPath.endsWith(".yarn_integrity");
 }
 
 // src/utils/nuxt/renderNuxtTemplate.ts
@@ -525,7 +1508,7 @@ import { generateCode, parseModule } from "magicast";
 import { addNuxtModule, getDefaultExportOptions } from "magicast/helpers";
 async function renderNuxtTemplate(ctx) {
   const {
-    cwd,
+    cwd: cwd2,
     projectName,
     projectRoot,
     useNuxtV4Compat,
@@ -544,9 +1527,9 @@ async function renderNuxtTemplate(ctx) {
       return "bun x";
     return "npm exec";
   });
-  let [command, ...args] = fullCustomCommand.split(" ");
-  const nuxiCli = spawnSync3(command, args, {
-    cwd,
+  const [command, ...args] = fullCustomCommand.split(" ");
+  const nuxiCli = spawnSync2(command, args, {
+    cwd: cwd2,
     stdio: ["inherit", "inherit", "pipe"],
     shell: true
   });
@@ -816,7 +1799,7 @@ ${banner}
   };
   const {
     canOverwrite,
-    cwd,
+    cwd: cwd2,
     projectName,
     useTypeScript,
     usePackageManager,
@@ -829,16 +1812,16 @@ ${banner}
     useNuxtSSR,
     useNuxtSSRClientHints
   } = await initPrompts(context);
-  const projectRoot = join2(cwd, projectName);
+  const projectRoot = join3(cwd2, projectName);
   if (canOverwrite) {
     rmSync(projectRoot, { recursive: true });
   }
   const preset = context.usePreset ?? usePreset;
   if (preset.startsWith("nuxt-")) {
-    const templateRoot = resolve3(dirname2(fileURLToPath(import.meta.url)), "../template/typescript");
-    const templatePath = resolve3(dirname2(fileURLToPath(import.meta.url)), "../template/typescript/nuxt");
+    const templateRoot = resolve4(dirname3(fileURLToPath(import.meta.url)), "../template/typescript");
+    const templatePath = resolve4(dirname3(fileURLToPath(import.meta.url)), "../template/typescript/nuxt");
     await renderNuxtTemplate({
-      cwd,
+      cwd: cwd2,
       projectName,
       projectRoot,
       templateRoot,
@@ -851,21 +1834,21 @@ ${banner}
     });
   } else {
     mkdirSync2(projectRoot);
-    writeFileSync2(resolve3(projectRoot, "package.json"), JSON.stringify({ name: projectName }, null, 2));
+    writeFileSync2(resolve4(projectRoot, "package.json"), JSON.stringify({ name: projectName }, null, 2));
     console.log("\n\u25CC Generating scaffold...");
     const jsOrTs = useTypeScript ? "typescript" : "javascript";
-    let templatePath = resolve3(dirname2(fileURLToPath(import.meta.url)), "../template", jsOrTs);
-    renderTemplate(resolve3(templatePath, "default"), projectRoot);
+    const templatePath = resolve4(dirname3(fileURLToPath(import.meta.url)), "../template", jsOrTs);
+    renderTemplate(resolve4(templatePath, "default"), projectRoot);
     if (["base", "essentials"].includes(usePreset)) {
-      renderTemplate(resolve3(templatePath, "base"), projectRoot);
+      renderTemplate(resolve4(templatePath, "base"), projectRoot);
     }
     if (["essentials", "recommended"].includes(usePreset)) {
-      renderTemplate(resolve3(templatePath, "essentials"), projectRoot);
+      renderTemplate(resolve4(templatePath, "essentials"), projectRoot);
     }
     if (usePackageManager && installDeps) {
       console.log(`\u25CC Installing dependencies with ${usePackageManager}...
 `);
-      installDependencies(projectRoot, usePackageManager);
+      await installDependencies2(projectRoot, usePackageManager);
     }
   }
   console.log(`