@drmhse/authos-vue 0.2.4 → 0.2.5

package/dist/chunk-IUIUWQYL.mjs

@@ -0,0 +1,700 @@
+import { __exportAll } from './chunk-VVJVQ4JO.mjs';
+import { createRequire } from 'module';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { PassThrough } from 'stream';
+import { spawn } from 'child_process';
+import { normalize, delimiter, resolve, dirname } from 'path';
+import { cwd } from 'process';
+import d from 'readline';
+
+var f = /^[A-Za-z]:\//;
+function p(e = ``) {
+  return e && e.replace(/\\/g, `/`).replace(f, (e2) => e2.toUpperCase());
+}
+var ee = /^[/\\]{2}/;
+var te = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var m = /^[A-Za-z]:$/;
+var h = /^\/([A-Za-z]:)?$/;
+var g = function(e) {
+  if (e.length === 0) return `.`;
+  e = p(e);
+  let t2 = e.match(ee), n2 = x(e), r2 = e[e.length - 1] === `/`;
+  return e = b(e, !n2), e.length === 0 ? n2 ? `/` : r2 ? `./` : `.` : (r2 && (e += `/`), m.test(e) && (e += `/`), t2 ? n2 ? `//${e}` : `//./${e}` : n2 && !x(e) ? `/${e}` : e);
+};
+var _ = function(...e) {
+  let t2 = ``;
+  for (let n2 of e) if (n2) if (t2.length > 0) {
+    let e2 = t2[t2.length - 1] === `/`, r2 = n2[0] === `/`;
+    e2 && r2 ? t2 += n2.slice(1) : t2 += e2 || r2 ? n2 : `/${n2}`;
+  } else t2 += n2;
+  return g(t2);
+};
+function v() {
+  return typeof process < `u` && typeof process.cwd == `function` ? process.cwd().replace(/\\/g, `/`) : `/`;
+}
+var y = function(...e) {
+  e = e.map((e2) => p(e2));
+  let t2 = ``, n2 = false;
+  for (let r2 = e.length - 1; r2 >= -1 && !n2; r2--) {
+    let i2 = r2 >= 0 ? e[r2] : v();
+    !i2 || i2.length === 0 || (t2 = `${i2}/${t2}`, n2 = x(i2));
+  }
+  return t2 = b(t2, !n2), n2 && !x(t2) ? `/${t2}` : t2.length > 0 ? t2 : `.`;
+};
+function b(e, t2) {
+  let n2 = ``, r2 = 0, i2 = -1, a2 = 0, o2 = null;
+  for (let s2 = 0; s2 <= e.length; ++s2) {
+    if (s2 < e.length) o2 = e[s2];
+    else if (o2 === `/`) break;
+    else o2 = `/`;
+    if (o2 === `/`) {
+      if (!(i2 === s2 - 1 || a2 === 1)) if (a2 === 2) {
+        if (n2.length < 2 || r2 !== 2 || n2[n2.length - 1] !== `.` || n2[n2.length - 2] !== `.`) {
+          if (n2.length > 2) {
+            let e2 = n2.lastIndexOf(`/`);
+            e2 === -1 ? (n2 = ``, r2 = 0) : (n2 = n2.slice(0, e2), r2 = n2.length - 1 - n2.lastIndexOf(`/`)), i2 = s2, a2 = 0;
+            continue;
+          } else if (n2.length > 0) {
+            n2 = ``, r2 = 0, i2 = s2, a2 = 0;
+            continue;
+          }
+        }
+        t2 && (n2 += n2.length > 0 ? `/..` : `..`, r2 = 2);
+      } else n2.length > 0 ? n2 += `/${e.slice(i2 + 1, s2)}` : n2 = e.slice(i2 + 1, s2), r2 = s2 - i2 - 1;
+      i2 = s2, a2 = 0;
+    } else o2 === `.` && a2 !== -1 ? ++a2 : a2 = -1;
+  }
+  return n2;
+}
+var x = function(e) {
+  return te.test(e);
+};
+var S = function(e, t2) {
+  let n2 = y(e).replace(h, `$1`).split(`/`), r2 = y(t2).replace(h, `$1`).split(`/`);
+  if (r2[0][1] === `:` && n2[0][1] === `:` && n2[0] !== r2[0]) return r2.join(`/`);
+  let i2 = [...n2];
+  for (let e2 of i2) {
+    if (r2[0] !== e2) break;
+    n2.shift(), r2.shift();
+  }
+  return [...n2.map(() => `..`), ...r2].join(`/`);
+};
+var C = function(e) {
+  let t2 = p(e).replace(/\/$/, ``).split(`/`).slice(0, -1);
+  return t2.length === 1 && m.test(t2[0]) && (t2[0] += `/`), t2.join(`/`) || (x(e) ? `/` : `.`);
+};
+var ne = function(e, t2) {
+  let n2 = p(e).split(`/`), r2 = ``;
+  for (let e2 = n2.length - 1; e2 >= 0; e2--) {
+    let t3 = n2[e2];
+    if (t3) {
+      r2 = t3;
+      break;
+    }
+  }
+  return t2 && r2.endsWith(t2) ? r2.slice(0, -t2.length) : r2;
+};
+globalThis.process?.platform;
+var w = (e, t2) => () => (t2 || e((t2 = { exports: {} }).exports, t2), t2.exports);
+var T = createRequire(import.meta.url);
+var re = /^path$/i;
+var E = {
+  key: `PATH`,
+  value: ``
+};
+function D(e) {
+  for (let t2 in e) {
+    if (!Object.prototype.hasOwnProperty.call(e, t2) || !re.test(t2)) continue;
+    let n2 = e[t2];
+    return n2 ? {
+      key: t2,
+      value: n2
+    } : E;
+  }
+  return E;
+}
+function O(e, t2) {
+  let n2 = t2.value.split(delimiter), r2 = [], i2 = e, a2;
+  do
+    r2.push(resolve(i2, `node_modules`, `.bin`)), a2 = i2, i2 = dirname(i2);
+  while (i2 !== a2);
+  let c2 = r2.concat(n2).join(delimiter);
+  return {
+    key: t2.key,
+    value: c2
+  };
+}
+function k(e, t2) {
+  let n2 = {
+    ...process.env,
+    ...t2
+  }, r2 = O(e, D(n2));
+  return n2[r2.key] = r2.value, n2;
+}
+var A = (e) => {
+  let t2 = e.length, n2 = new PassThrough(), r2 = () => {
+    --t2 === 0 && n2.emit(`end`);
+  };
+  for (let t3 of e) t3.pipe(n2, { end: false }), t3.on(`end`, r2);
+  return n2;
+};
+var j = w(((e, t2) => {
+  t2.exports = a2, a2.sync = o2;
+  var n2 = T(`fs`);
+  function r2(e2, t3) {
+    var n3 = t3.pathExt === void 0 ? process.env.PATHEXT : t3.pathExt;
+    if (!n3 || (n3 = n3.split(`;`), n3.indexOf(``) !== -1)) return true;
+    for (var r3 = 0; r3 < n3.length; r3++) {
+      var i3 = n3[r3].toLowerCase();
+      if (i3 && e2.substr(-i3.length).toLowerCase() === i3) return true;
+    }
+    return false;
+  }
+  function i2(e2, t3, n3) {
+    return !e2.isSymbolicLink() && !e2.isFile() ? false : r2(t3, n3);
+  }
+  function a2(e2, t3, r3) {
+    n2.stat(e2, function(n3, a3) {
+      r3(n3, n3 ? false : i2(a3, e2, t3));
+    });
+  }
+  function o2(e2, t3) {
+    return i2(n2.statSync(e2), e2, t3);
+  }
+}));
+var M = w(((e, t2) => {
+  t2.exports = r2, r2.sync = i2;
+  var n2 = T(`fs`);
+  function r2(e2, t3, r3) {
+    n2.stat(e2, function(e3, n3) {
+      r3(e3, e3 ? false : a2(n3, t3));
+    });
+  }
+  function i2(e2, t3) {
+    return a2(n2.statSync(e2), t3);
+  }
+  function a2(e2, t3) {
+    return e2.isFile() && o2(e2, t3);
+  }
+  function o2(e2, t3) {
+    var n3 = e2.mode, r3 = e2.uid, i3 = e2.gid, a3 = t3.uid === void 0 ? process.getuid && process.getuid() : t3.uid, o3 = t3.gid === void 0 ? process.getgid && process.getgid() : t3.gid, s2 = 64, c2 = 8, l2 = 1, u2 = s2 | c2;
+    return n3 & l2 || n3 & c2 && i3 === o3 || n3 & s2 && r3 === a3 || n3 & u2 && a3 === 0;
+  }
+}));
+var N = w(((e, t2) => {
+  T(`fs`);
+  var n2 = process.platform === `win32` || global.TESTING_WINDOWS ? j() : M();
+  t2.exports = r2, r2.sync = i2;
+  function r2(e2, t3, i3) {
+    if (typeof t3 == `function` && (i3 = t3, t3 = {}), !i3) {
+      if (typeof Promise != `function`) throw TypeError(`callback not provided`);
+      return new Promise(function(n3, i4) {
+        r2(e2, t3 || {}, function(e3, t4) {
+          e3 ? i4(e3) : n3(t4);
+        });
+      });
+    }
+    n2(e2, t3 || {}, function(e3, n3) {
+      e3 && (e3.code === `EACCES` || t3 && t3.ignoreErrors) && (e3 = null, n3 = false), i3(e3, n3);
+    });
+  }
+  function i2(e2, t3) {
+    try {
+      return n2.sync(e2, t3 || {});
+    } catch (e3) {
+      if (t3 && t3.ignoreErrors || e3.code === `EACCES`) return false;
+      throw e3;
+    }
+  }
+}));
+var P = w(((e, t2) => {
+  let n2 = process.platform === `win32` || process.env.OSTYPE === `cygwin` || process.env.OSTYPE === `msys`, r2 = T(`path`), i2 = n2 ? `;` : `:`, a2 = N(), o2 = (e2) => Object.assign(Error(`not found: ${e2}`), { code: `ENOENT` }), s2 = (e2, t3) => {
+    let r3 = t3.colon || i2, a3 = e2.match(/\//) || n2 && e2.match(/\\/) ? [``] : [...n2 ? [process.cwd()] : [], ...(t3.path || process.env.PATH || ``).split(r3)], o3 = n2 ? t3.pathExt || process.env.PATHEXT || `.EXE;.CMD;.BAT;.COM` : ``, s3 = n2 ? o3.split(r3) : [``];
+    return n2 && e2.indexOf(`.`) !== -1 && s3[0] !== `` && s3.unshift(``), {
+      pathEnv: a3,
+      pathExt: s3,
+      pathExtExe: o3
+    };
+  }, c2 = (e2, t3, n3) => {
+    typeof t3 == `function` && (n3 = t3, t3 = {}), t3 ||= {};
+    let { pathEnv: i3, pathExt: c3, pathExtExe: l2 } = s2(e2, t3), u2 = [], d2 = (n4) => new Promise((a3, s3) => {
+      if (n4 === i3.length) return t3.all && u2.length ? a3(u2) : s3(o2(e2));
+      let c4 = i3[n4], l3 = /^".*"$/.test(c4) ? c4.slice(1, -1) : c4, d3 = r2.join(l3, e2);
+      a3(f2(!l3 && /^\.[\\\/]/.test(e2) ? e2.slice(0, 2) + d3 : d3, n4, 0));
+    }), f2 = (e3, n4, r3) => new Promise((i4, o3) => {
+      if (r3 === c3.length) return i4(d2(n4 + 1));
+      let s3 = c3[r3];
+      a2(e3 + s3, { pathExt: l2 }, (a3, o4) => {
+        if (!a3 && o4) if (t3.all) u2.push(e3 + s3);
+        else return i4(e3 + s3);
+        return i4(f2(e3, n4, r3 + 1));
+      });
+    });
+    return n3 ? d2(0).then((e3) => n3(null, e3), n3) : d2(0);
+  };
+  t2.exports = c2, c2.sync = (e2, t3) => {
+    t3 ||= {};
+    let { pathEnv: n3, pathExt: i3, pathExtExe: c3 } = s2(e2, t3), l2 = [];
+    for (let o3 = 0; o3 < n3.length; o3++) {
+      let s3 = n3[o3], u2 = /^".*"$/.test(s3) ? s3.slice(1, -1) : s3, d2 = r2.join(u2, e2), f2 = !u2 && /^\.[\\\/]/.test(e2) ? e2.slice(0, 2) + d2 : d2;
+      for (let e3 = 0; e3 < i3.length; e3++) {
+        let n4 = f2 + i3[e3];
+        try {
+          if (a2.sync(n4, { pathExt: c3 })) if (t3.all) l2.push(n4);
+          else return n4;
+        } catch {
+        }
+      }
+    }
+    if (t3.all && l2.length) return l2;
+    if (t3.nothrow) return null;
+    throw o2(e2);
+  };
+}));
+var F = w(((e, t2) => {
+  let n2 = (e2 = {}) => {
+    let t3 = e2.env || process.env;
+    return (e2.platform || process.platform) === `win32` ? Object.keys(t3).reverse().find((e3) => e3.toUpperCase() === `PATH`) || `Path` : `PATH`;
+  };
+  t2.exports = n2, t2.exports.default = n2;
+}));
+var I = w(((e, t2) => {
+  let n2 = T(`path`), r2 = P(), i2 = F();
+  function a2(e2, t3) {
+    let a3 = e2.options.env || process.env, o3 = process.cwd(), s2 = e2.options.cwd != null, c2 = s2 && process.chdir !== void 0 && !process.chdir.disabled;
+    if (c2) try {
+      process.chdir(e2.options.cwd);
+    } catch {
+    }
+    let l2;
+    try {
+      l2 = r2.sync(e2.command, {
+        path: a3[i2({ env: a3 })],
+        pathExt: t3 ? n2.delimiter : void 0
+      });
+    } catch {
+    } finally {
+      c2 && process.chdir(o3);
+    }
+    return l2 &&= n2.resolve(s2 ? e2.options.cwd : ``, l2), l2;
+  }
+  function o2(e2) {
+    return a2(e2) || a2(e2, true);
+  }
+  t2.exports = o2;
+}));
+var L = w(((e, t2) => {
+  let n2 = /([()\][%!^"`<>&|;, *?])/g;
+  function r2(e2) {
+    return e2 = e2.replace(n2, `^$1`), e2;
+  }
+  function i2(e2, t3) {
+    return e2 = `${e2}`, e2 = e2.replace(/(?=(\\+?)?)\1"/g, `$1$1\\"`), e2 = e2.replace(/(?=(\\+?)?)\1$/, `$1$1`), e2 = `"${e2}"`, e2 = e2.replace(n2, `^$1`), t3 && (e2 = e2.replace(n2, `^$1`)), e2;
+  }
+  t2.exports.command = r2, t2.exports.argument = i2;
+}));
+var R = w(((e, t2) => {
+  t2.exports = /^#!(.*)/;
+}));
+var z = w(((e, t2) => {
+  let n2 = R();
+  t2.exports = (e2 = ``) => {
+    let t3 = e2.match(n2);
+    if (!t3) return null;
+    let [r2, i2] = t3[0].replace(/#! ?/, ``).split(` `), a2 = r2.split(`/`).pop();
+    return a2 === `env` ? i2 : i2 ? `${a2} ${i2}` : a2;
+  };
+}));
+var B = w(((e, t2) => {
+  let n2 = T(`fs`), r2 = z();
+  function i2(e2) {
+    let t3 = Buffer.alloc(150), i3;
+    try {
+      i3 = n2.openSync(e2, `r`), n2.readSync(i3, t3, 0, 150, 0), n2.closeSync(i3);
+    } catch {
+    }
+    return r2(t3.toString());
+  }
+  t2.exports = i2;
+}));
+var V = w(((e, t2) => {
+  let n2 = T(`path`), r2 = I(), i2 = L(), a2 = B(), o2 = process.platform === `win32`, s2 = /\.(?:com|exe)$/i, c2 = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function l2(e2) {
+    e2.file = r2(e2);
+    let t3 = e2.file && a2(e2.file);
+    return t3 ? (e2.args.unshift(e2.file), e2.command = t3, r2(e2)) : e2.file;
+  }
+  function u2(e2) {
+    if (!o2) return e2;
+    let t3 = l2(e2), r3 = !s2.test(t3);
+    if (e2.options.forceShell || r3) {
+      let r4 = c2.test(t3);
+      e2.command = n2.normalize(e2.command), e2.command = i2.command(e2.command), e2.args = e2.args.map((e3) => i2.argument(e3, r4)), e2.args = [
+        `/d`,
+        `/s`,
+        `/c`,
+        `"${[e2.command].concat(e2.args).join(` `)}"`
+      ], e2.command = process.env.comspec || `cmd.exe`, e2.options.windowsVerbatimArguments = true;
+    }
+    return e2;
+  }
+  function d2(e2, t3, n3) {
+    t3 && !Array.isArray(t3) && (n3 = t3, t3 = null), t3 = t3 ? t3.slice(0) : [], n3 = Object.assign({}, n3);
+    let r3 = {
+      command: e2,
+      args: t3,
+      options: n3,
+      file: void 0,
+      original: {
+        command: e2,
+        args: t3
+      }
+    };
+    return n3.shell ? r3 : u2(r3);
+  }
+  t2.exports = d2;
+}));
+var ie = w(((e, t2) => {
+  let n2 = process.platform === `win32`;
+  function r2(e2, t3) {
+    return Object.assign(Error(`${t3} ${e2.command} ENOENT`), {
+      code: `ENOENT`,
+      errno: `ENOENT`,
+      syscall: `${t3} ${e2.command}`,
+      path: e2.command,
+      spawnargs: e2.args
+    });
+  }
+  function i2(e2, t3) {
+    if (!n2) return;
+    let r3 = e2.emit;
+    e2.emit = function(n3, i3) {
+      if (n3 === `exit`) {
+        let n4 = a2(i3, t3);
+        if (n4) return r3.call(e2, `error`, n4);
+      }
+      return r3.apply(e2, arguments);
+    };
+  }
+  function a2(e2, t3) {
+    return n2 && e2 === 1 && !t3.file ? r2(t3.original, `spawn`) : null;
+  }
+  function o2(e2, t3) {
+    return n2 && e2 === 1 && !t3.file ? r2(t3.original, `spawnSync`) : null;
+  }
+  t2.exports = {
+    hookChildProcess: i2,
+    verifyENOENT: a2,
+    verifyENOENTSync: o2,
+    notFoundError: r2
+  };
+}));
+var H = w(((e, t2) => {
+  let n2 = T(`child_process`), r2 = V(), i2 = ie();
+  function a2(e2, t3, a3) {
+    let o3 = r2(e2, t3, a3), s2 = n2.spawn(o3.command, o3.args, o3.options);
+    return i2.hookChildProcess(s2, o3), s2;
+  }
+  function o2(e2, t3, a3) {
+    let o3 = r2(e2, t3, a3), s2 = n2.spawnSync(o3.command, o3.args, o3.options);
+    return s2.error = s2.error || i2.verifyENOENTSync(s2.status, o3), s2;
+  }
+  t2.exports = a2, t2.exports.spawn = a2, t2.exports.sync = o2, t2.exports._parse = r2, t2.exports._enoent = i2;
+}))();
+var U = class extends Error {
+  result;
+  output;
+  get exitCode() {
+    if (this.result.exitCode !== null) return this.result.exitCode;
+  }
+  constructor(e, t2) {
+    super(`Process exited with non-zero status (${e.exitCode})`), this.result = e, this.output = t2;
+  }
+};
+var W = {
+  timeout: void 0,
+  persist: false
+};
+var G = { windowsHide: true };
+function K(e, t2) {
+  return {
+    command: normalize(e),
+    args: t2 ?? []
+  };
+}
+function q(e) {
+  let t2 = new AbortController();
+  for (let n2 of e) {
+    if (n2.aborted) return t2.abort(), n2;
+    n2.addEventListener(`abort`, () => {
+      t2.abort(n2.reason);
+    }, { signal: t2.signal });
+  }
+  return t2.signal;
+}
+async function J(e) {
+  let t2 = ``;
+  for await (let n2 of e) t2 += n2.toString();
+  return t2;
+}
+var Y = 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, t2, n2) {
+    this._options = {
+      ...W,
+      ...n2
+    }, this._command = e, this._args = t2 ?? [], this._processClosed = new Promise((e2) => {
+      this._resolveClose = e2;
+    });
+  }
+  kill(e) {
+    return this._process?.kill(e) === true;
+  }
+  get aborted() {
+    return this._aborted;
+  }
+  get killed() {
+    return this._process?.killed === true;
+  }
+  pipe(e, t2, n2) {
+    return ae(e, t2, {
+      ...n2,
+      stdin: this
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    let e = this._process;
+    if (!e) return;
+    let t2 = [];
+    this._streamErr && t2.push(this._streamErr), this._streamOut && t2.push(this._streamOut);
+    let n2 = A(t2), r2 = d.createInterface({ input: n2 });
+    for await (let e2 of r2) yield e2.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 U(this);
+  }
+  async _waitForOutput() {
+    let e = this._process;
+    if (!e) throw Error(`No process was started`);
+    let [t2, n2] = await Promise.all([this._streamOut ? J(this._streamOut) : ``, this._streamErr ? J(this._streamErr) : ``]);
+    if (await this._processClosed, this._options?.stdin && await this._options.stdin, e.removeAllListeners(), this._thrownError) throw this._thrownError;
+    let r2 = {
+      stderr: n2,
+      stdout: t2,
+      exitCode: this.exitCode
+    };
+    if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new U(this, r2);
+    return r2;
+  }
+  then(e, t2) {
+    return this._waitForOutput().then(e, t2);
+  }
+  _streamOut;
+  _streamErr;
+  spawn() {
+    let e = cwd(), t2 = this._options, n2 = {
+      ...G,
+      ...t2.nodeOptions
+    }, r2 = [];
+    this._resetState(), t2.timeout !== void 0 && r2.push(AbortSignal.timeout(t2.timeout)), t2.signal !== void 0 && r2.push(t2.signal), t2.persist === true && (n2.detached = true), r2.length > 0 && (n2.signal = q(r2)), n2.env = k(e, n2.env);
+    let { command: i2, args: o2 } = K(this._command, this._args), s2 = (0, H._parse)(i2, o2, n2), c2 = spawn(s2.command, s2.args, s2.options);
+    if (c2.stderr && (this._streamErr = c2.stderr), c2.stdout && (this._streamOut = c2.stdout), this._process = c2, c2.once(`error`, this._onError), c2.once(`close`, this._onClose), t2.stdin !== void 0 && c2.stdin && t2.stdin.process) {
+      let { stdout: e2 } = t2.stdin.process;
+      e2 && e2.pipe(c2.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 X = (e, t2, n2) => {
+  let r2 = new Y(e, t2, n2);
+  return r2.spawn(), r2;
+};
+var ae = X;
+var oe = __exportAll({
+  detectPackageManager: () => $,
+  installDependencies: () => fe,
+  packageManagers: () => Q
+});
+async function se(e, t2, n2 = {}) {
+  let r2 = g(e).split(`/`);
+  for (; r2.length > 0; ) {
+    let e2 = await t2(r2.join(`/`) || `/`);
+    if (e2 || !n2.includeParentDirs) return e2;
+    r2.pop();
+  }
+}
+function ce(e) {
+  let t2;
+  return () => (t2 === void 0 && (t2 = e().then((e2) => (t2 = e2, t2))), t2);
+}
+var Z = ce(async () => {
+  if (globalThis.process?.versions?.webcontainer) return false;
+  try {
+    let { exitCode: e } = await X(`corepack`, [`--version`]);
+    return e === 0;
+  } catch {
+    return false;
+  }
+});
+async function le(e, t2, n2 = {}) {
+  let r2 = e !== `npm` && e !== `bun` && e !== `deno` && n2.corepack !== false && await Z() ? [`corepack`, [e, ...t2]] : [e, t2], { exitCode: i2, stdout: a2, stderr: o2 } = await X(r2[0], r2[1], { nodeOptions: {
+    cwd: y(n2.cwd || process.cwd()),
+    env: n2.env,
+    stdio: n2.silent ? `pipe` : `inherit`
+  } });
+  if (i2 !== 0) throw Error(`\`${r2.flat().join(` `)}\` failed.${n2.silent ? [
+    ``,
+    a2,
+    o2
+  ].join(`
+`) : ``}`);
+}
+async function ue(e = {}) {
+  let t2 = e.cwd || process.cwd(), n2 = {
+    ...process.env,
+    ...e.env
+  }, r2 = (typeof e.packageManager == `string` ? Q.find((t3) => t3.name === e.packageManager) : e.packageManager) || await $(e.cwd || process.cwd());
+  if (!r2) throw Error(`No package manager auto-detected.`);
+  return {
+    cwd: t2,
+    env: n2,
+    silent: e.silent ?? false,
+    packageManager: r2,
+    dev: e.dev ?? false,
+    workspace: e.workspace,
+    global: e.global ?? false,
+    dry: e.dry ?? false,
+    corepack: e.corepack ?? true
+  };
+}
+function de(e) {
+  let [t2, n2] = (e || ``).split(`@`), [r2, i2] = n2?.split(`+`) || [];
+  if (t2 && t2 !== `-` && /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(t2)) return {
+    name: t2,
+    version: r2,
+    buildMeta: i2
+  };
+  let a2 = (t2 || ``).replace(/\W+/g, ``);
+  return {
+    name: a2,
+    version: r2,
+    buildMeta: i2,
+    warnings: [`Abnormal characters found in \`packageManager\` field, sanitizing from \`${t2}\` to \`${a2}\``]
+  };
+}
+var Q = [
+  {
+    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 $(e, t2 = {}) {
+  let i2 = await se(y(e || `.`), async (e2) => {
+    if (!t2.ignorePackageJSON) {
+      let t3 = _(e2, `package.json`);
+      if (existsSync(t3)) {
+        let e3 = JSON.parse(await readFile(t3, `utf8`));
+        if (e3?.packageManager) {
+          let { name: t4, version: n2 = `0.0.0`, buildMeta: r2, warnings: i3 } = de(e3.packageManager);
+          if (t4) {
+            let e4 = n2.split(`.`)[0], a2 = Q.find((n3) => n3.name === t4 && n3.majorVersion === e4) || Q.find((e5) => e5.name === t4);
+            return {
+              name: t4,
+              command: t4,
+              version: n2,
+              majorVersion: e4,
+              buildMeta: r2,
+              warnings: i3,
+              files: a2?.files,
+              lockFile: a2?.lockFile
+            };
+          }
+        }
+      }
+      if (existsSync(_(e2, `deno.json`))) return Q.find((e3) => e3.name === `deno`);
+    }
+    if (!t2.ignoreLockFile) {
+      for (let t3 of Q) if ([t3.lockFile, t3.files].flat().filter(Boolean).some((t4) => existsSync(y(e2, t4)))) return { ...t3 };
+    }
+  }, { includeParentDirs: t2.includeParentDirs ?? true });
+  if (!i2 && !t2.ignoreArgv) {
+    let e2 = process.argv[1];
+    if (e2) {
+      for (let t3 of Q) if (RegExp(`[/\\\\]\\.?${t3.command}`).test(e2)) return t3;
+    }
+  }
+  return i2;
+}
+async function fe(e = {}) {
+  let t2 = await ue(e), n2 = e.frozenLockFile ? {
+    npm: [`ci`],
+    yarn: [`install`, `--immutable`],
+    bun: [`install`, `--frozen-lockfile`],
+    pnpm: [`install`, `--frozen-lockfile`],
+    deno: [`install`, `--frozen`]
+  }[t2.packageManager.name] : [`install`];
+  return e.ignoreWorkspace && t2.packageManager.name === `pnpm` && n2.push(`--ignore-workspace`), t2.dry || await le(t2.packageManager.command, n2, {
+    cwd: t2.cwd,
+    silent: t2.silent,
+    corepack: t2.corepack
+  }), { exec: {
+    command: t2.packageManager.command,
+    args: n2
+  } };
+}
+
+export { C, S, ne, oe, y };