@lousy-agents/mcp 5.8.0 → 5.8.2

package/dist/511.js

@@ -0,0 +1,1260 @@
+export const __rspack_esm_id = "511";
+export const __rspack_esm_ids = ["511"];
+export const __webpack_modules__ = {
+292(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  a: () => (y),
+  n: () => (ne),
+  r: () => (C),
+  t: () => (oe)
+});
+/* import */ var _rolldown_runtime_mjs__rspack_import_8 = __webpack_require__(421);
+/* import */ var node_module__rspack_import_0 = __webpack_require__(8995);
+/* import */ var node_fs__rspack_import_1 = __webpack_require__(3024);
+/* import */ var node_fs_promises__rspack_import_2 = __webpack_require__(1455);
+/* import */ var node_stream__rspack_import_3 = __webpack_require__(7075);
+/* import */ var node_child_process__rspack_import_4 = __webpack_require__(1421);
+/* import */ var node_path__rspack_import_5 = __webpack_require__(6760);
+/* import */ var node_process__rspack_import_6 = __webpack_require__(1708);
+/* import */ var node_readline__rspack_import_7 = __webpack_require__(481);
+
+
+
+
+
+
+
+
+
+const f = /^[A-Za-z]:\//;
+function p(e = ``) {
+	return e && e.replace(/\\/g, `/`).replace(f, (e) => e.toUpperCase());
+}
+const ee = /^[/\\]{2}/, te = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, m = /^[A-Za-z]:$/, h = /^\/([A-Za-z]:)?$/, g = function(e) {
+	if (e.length === 0) return `.`;
+	e = p(e);
+	let t = e.match(ee), n = x(e), r = e[e.length - 1] === `/`;
+	return e = b(e, !n), e.length === 0 ? n ? `/` : r ? `./` : `.` : (r && (e += `/`), m.test(e) && (e += `/`), t ? n ? `//${e}` : `//./${e}` : n && !x(e) ? `/${e}` : e);
+}, _ = function(...e) {
+	let t = ``;
+	for (let n of e) if (n) if (t.length > 0) {
+		let e = t[t.length - 1] === `/`, r = n[0] === `/`;
+		e && r ? t += n.slice(1) : t += e || r ? n : `/${n}`;
+	} else t += n;
+	return g(t);
+};
+function v() {
+	return typeof process < `u` && typeof process.cwd == `function` ? process.cwd().replace(/\\/g, `/`) : `/`;
+}
+const y = function(...e) {
+	e = e.map((e) => p(e));
+	let t = ``, n = !1;
+	for (let r = e.length - 1; r >= -1 && !n; r--) {
+		let i = r >= 0 ? e[r] : v();
+		!i || i.length === 0 || (t = `${i}/${t}`, n = x(i));
+	}
+	return t = b(t, !n), n && !x(t) ? `/${t}` : t.length > 0 ? t : `.`;
+};
+function b(e, t) {
+	let n = ``, r = 0, i = -1, a = 0, o = null;
+	for (let s = 0; s <= e.length; ++s) {
+		if (s < e.length) o = e[s];
+		else if (o === `/`) break;
+		else o = `/`;
+		if (o === `/`) {
+			if (!(i === s - 1 || a === 1)) if (a === 2) {
+				if (n.length < 2 || r !== 2 || n[n.length - 1] !== `.` || n[n.length - 2] !== `.`) {
+					if (n.length > 2) {
+						let e = n.lastIndexOf(`/`);
+						e === -1 ? (n = ``, r = 0) : (n = n.slice(0, e), r = n.length - 1 - n.lastIndexOf(`/`)), i = s, a = 0;
+						continue;
+					} else if (n.length > 0) {
+						n = ``, r = 0, i = s, a = 0;
+						continue;
+					}
+				}
+				t && (n += n.length > 0 ? `/..` : `..`, r = 2);
+			} else n.length > 0 ? n += `/${e.slice(i + 1, s)}` : n = e.slice(i + 1, s), r = s - i - 1;
+			i = s, a = 0;
+		} else o === `.` && a !== -1 ? ++a : a = -1;
+	}
+	return n;
+}
+const x = function(e) {
+	return te.test(e);
+}, S = function(e, t) {
+	let n = y(e).replace(h, `$1`).split(`/`), r = y(t).replace(h, `$1`).split(`/`);
+	if (r[0][1] === `:` && n[0][1] === `:` && n[0] !== r[0]) return r.join(`/`);
+	let i = [...n];
+	for (let e of i) {
+		if (r[0] !== e) break;
+		n.shift(), r.shift();
+	}
+	return [...n.map(() => `..`), ...r].join(`/`);
+}, C = function(e) {
+	let t = p(e).replace(/\/$/, ``).split(`/`).slice(0, -1);
+	return t.length === 1 && m.test(t[0]) && (t[0] += `/`), t.join(`/`) || (x(e) ? `/` : `.`);
+}, ne = function(e, t) {
+	let n = p(e).split(`/`), r = ``;
+	for (let e = n.length - 1; e >= 0; e--) {
+		let t = n[e];
+		if (t) {
+			r = t;
+			break;
+		}
+	}
+	return t && r.endsWith(t) ? r.slice(0, -t.length) : r;
+};
+globalThis.process?.platform;
+var w = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), T = (0,node_module__rspack_import_0.createRequire)(import.meta.url);
+const re = /^path$/i, E = {
+	key: `PATH`,
+	value: ``
+};
+function D(e) {
+	for (let t in e) {
+		if (!Object.prototype.hasOwnProperty.call(e, t) || !re.test(t)) continue;
+		let n = e[t];
+		return n ? {
+			key: t,
+			value: n
+		} : E;
+	}
+	return E;
+}
+function O(e, t) {
+	let n = t.value.split(node_path__rspack_import_5.delimiter), r = [], i = e, a;
+	do
+		r.push((0,node_path__rspack_import_5.resolve)(i, `node_modules`, `.bin`)), a = i, i = (0,node_path__rspack_import_5.dirname)(i);
+	while (i !== a);
+	let c = r.concat(n).join(node_path__rspack_import_5.delimiter);
+	return {
+		key: t.key,
+		value: c
+	};
+}
+function k(e, t) {
+	let n = {
+		...process.env,
+		...t
+	}, r = O(e, D(n));
+	return n[r.key] = r.value, n;
+}
+const A = (e) => {
+	let t = e.length, n = new node_stream__rspack_import_3.PassThrough(), r = () => {
+		--t === 0 && n.emit(`end`);
+	};
+	for (let t of e) t.pipe(n, { end: !1 }), t.on(`end`, r);
+	return n;
+};
+var j = w(((e, t) => {
+	t.exports = a, a.sync = o;
+	var n = T(`fs`);
+	function r(e, t) {
+		var n = t.pathExt === void 0 ? process.env.PATHEXT : t.pathExt;
+		if (!n || (n = n.split(`;`), n.indexOf(``) !== -1)) return !0;
+		for (var r = 0; r < n.length; r++) {
+			var i = n[r].toLowerCase();
+			if (i && e.substr(-i.length).toLowerCase() === i) return !0;
+		}
+		return !1;
+	}
+	function i(e, t, n) {
+		return !e.isSymbolicLink() && !e.isFile() ? !1 : r(t, n);
+	}
+	function a(e, t, r) {
+		n.stat(e, function(n, a) {
+			r(n, n ? !1 : i(a, e, t));
+		});
+	}
+	function o(e, t) {
+		return i(n.statSync(e), e, t);
+	}
+})), M = w(((e, t) => {
+	t.exports = r, r.sync = i;
+	var n = T(`fs`);
+	function r(e, t, r) {
+		n.stat(e, function(e, n) {
+			r(e, e ? !1 : a(n, t));
+		});
+	}
+	function i(e, t) {
+		return a(n.statSync(e), t);
+	}
+	function a(e, t) {
+		return e.isFile() && o(e, t);
+	}
+	function o(e, t) {
+		var n = e.mode, r = e.uid, i = e.gid, a = t.uid === void 0 ? process.getuid && process.getuid() : t.uid, o = t.gid === void 0 ? process.getgid && process.getgid() : t.gid, s = 64, c = 8, l = 1, u = s | c;
+		return n & l || n & c && i === o || n & s && r === a || n & u && a === 0;
+	}
+})), N = w(((e, t) => {
+	T(`fs`);
+	var n = process.platform === `win32` || global.TESTING_WINDOWS ? j() : M();
+	t.exports = r, r.sync = i;
+	function r(e, t, i) {
+		if (typeof t == `function` && (i = t, t = {}), !i) {
+			if (typeof Promise != `function`) throw TypeError(`callback not provided`);
+			return new Promise(function(n, i) {
+				r(e, t || {}, function(e, t) {
+					e ? i(e) : n(t);
+				});
+			});
+		}
+		n(e, t || {}, function(e, n) {
+			e && (e.code === `EACCES` || t && t.ignoreErrors) && (e = null, n = !1), i(e, n);
+		});
+	}
+	function i(e, t) {
+		try {
+			return n.sync(e, t || {});
+		} catch (e) {
+			if (t && t.ignoreErrors || e.code === `EACCES`) return !1;
+			throw e;
+		}
+	}
+})), P = w(((e, t) => {
+	let n = process.platform === `win32` || process.env.OSTYPE === `cygwin` || process.env.OSTYPE === `msys`, r = T(`path`), i = n ? `;` : `:`, a = N(), o = (e) => Object.assign(Error(`not found: ${e}`), { code: `ENOENT` }), s = (e, t) => {
+		let r = t.colon || i, a = e.match(/\//) || n && e.match(/\\/) ? [``] : [...n ? [process.cwd()] : [], ...(t.path || process.env.PATH || ``).split(r)], o = n ? t.pathExt || process.env.PATHEXT || `.EXE;.CMD;.BAT;.COM` : ``, s = n ? o.split(r) : [``];
+		return n && e.indexOf(`.`) !== -1 && s[0] !== `` && s.unshift(``), {
+			pathEnv: a,
+			pathExt: s,
+			pathExtExe: o
+		};
+	}, c = (e, t, n) => {
+		typeof t == `function` && (n = t, t = {}), t ||= {};
+		let { pathEnv: i, pathExt: c, pathExtExe: l } = s(e, t), u = [], d = (n) => new Promise((a, s) => {
+			if (n === i.length) return t.all && u.length ? a(u) : s(o(e));
+			let c = i[n], l = /^".*"$/.test(c) ? c.slice(1, -1) : c, d = r.join(l, e);
+			a(f(!l && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d, n, 0));
+		}), f = (e, n, r) => new Promise((i, o) => {
+			if (r === c.length) return i(d(n + 1));
+			let s = c[r];
+			a(e + s, { pathExt: l }, (a, o) => {
+				if (!a && o) if (t.all) u.push(e + s);
+				else return i(e + s);
+				return i(f(e, n, r + 1));
+			});
+		});
+		return n ? d(0).then((e) => n(null, e), n) : d(0);
+	};
+	t.exports = c, c.sync = (e, t) => {
+		t ||= {};
+		let { pathEnv: n, pathExt: i, pathExtExe: c } = s(e, t), l = [];
+		for (let o = 0; o < n.length; o++) {
+			let s = n[o], u = /^".*"$/.test(s) ? s.slice(1, -1) : s, d = r.join(u, e), f = !u && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d;
+			for (let e = 0; e < i.length; e++) {
+				let n = f + i[e];
+				try {
+					if (a.sync(n, { pathExt: c })) if (t.all) l.push(n);
+					else return n;
+				} catch {}
+			}
+		}
+		if (t.all && l.length) return l;
+		if (t.nothrow) return null;
+		throw o(e);
+	};
+})), F = w(((e, t) => {
+	let n = (e = {}) => {
+		let t = e.env || process.env;
+		return (e.platform || process.platform) === `win32` ? Object.keys(t).reverse().find((e) => e.toUpperCase() === `PATH`) || `Path` : `PATH`;
+	};
+	t.exports = n, t.exports.default = n;
+})), I = w(((e, t) => {
+	let n = T(`path`), r = P(), i = F();
+	function a(e, t) {
+		let a = e.options.env || process.env, o = process.cwd(), s = e.options.cwd != null, c = s && process.chdir !== void 0 && !process.chdir.disabled;
+		if (c) try {
+			process.chdir(e.options.cwd);
+		} catch {}
+		let l;
+		try {
+			l = r.sync(e.command, {
+				path: a[i({ env: a })],
+				pathExt: t ? n.delimiter : void 0
+			});
+		} catch {} finally {
+			c && process.chdir(o);
+		}
+		return l &&= n.resolve(s ? e.options.cwd : ``, l), l;
+	}
+	function o(e) {
+		return a(e) || a(e, !0);
+	}
+	t.exports = o;
+})), L = w(((e, t) => {
+	let n = /([()\][%!^"`<>&|;, *?])/g;
+	function r(e) {
+		return e = e.replace(n, `^$1`), e;
+	}
+	function i(e, t) {
+		return e = `${e}`, e = e.replace(/(?=(\\+?)?)\1"/g, `$1$1\\"`), e = e.replace(/(?=(\\+?)?)\1$/, `$1$1`), e = `"${e}"`, e = e.replace(n, `^$1`), t && (e = e.replace(n, `^$1`)), e;
+	}
+	t.exports.command = r, t.exports.argument = i;
+})), R = w(((e, t) => {
+	t.exports = /^#!(.*)/;
+})), z = w(((e, t) => {
+	let n = R();
+	t.exports = (e = ``) => {
+		let t = e.match(n);
+		if (!t) return null;
+		let [r, i] = t[0].replace(/#! ?/, ``).split(` `), a = r.split(`/`).pop();
+		return a === `env` ? i : i ? `${a} ${i}` : a;
+	};
+})), B = w(((e, t) => {
+	let n = T(`fs`), r = z();
+	function i(e) {
+		let t = Buffer.alloc(150), i;
+		try {
+			i = n.openSync(e, `r`), n.readSync(i, t, 0, 150, 0), n.closeSync(i);
+		} catch {}
+		return r(t.toString());
+	}
+	t.exports = i;
+})), V = w(((e, t) => {
+	let n = T(`path`), r = I(), i = L(), a = B(), o = process.platform === `win32`, s = /\.(?:com|exe)$/i, c = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function l(e) {
+		e.file = r(e);
+		let t = e.file && a(e.file);
+		return t ? (e.args.unshift(e.file), e.command = t, r(e)) : e.file;
+	}
+	function u(e) {
+		if (!o) return e;
+		let t = l(e), r = !s.test(t);
+		if (e.options.forceShell || r) {
+			let r = c.test(t);
+			e.command = n.normalize(e.command), e.command = i.command(e.command), e.args = e.args.map((e) => i.argument(e, r)), e.args = [
+				`/d`,
+				`/s`,
+				`/c`,
+				`"${[e.command].concat(e.args).join(` `)}"`
+			], e.command = process.env.comspec || `cmd.exe`, e.options.windowsVerbatimArguments = !0;
+		}
+		return e;
+	}
+	function d(e, t, n) {
+		t && !Array.isArray(t) && (n = t, t = null), t = t ? t.slice(0) : [], n = Object.assign({}, n);
+		let r = {
+			command: e,
+			args: t,
+			options: n,
+			file: void 0,
+			original: {
+				command: e,
+				args: t
+			}
+		};
+		return n.shell ? r : u(r);
+	}
+	t.exports = d;
+})), ie = w(((e, t) => {
+	let n = process.platform === `win32`;
+	function r(e, t) {
+		return Object.assign(Error(`${t} ${e.command} ENOENT`), {
+			code: `ENOENT`,
+			errno: `ENOENT`,
+			syscall: `${t} ${e.command}`,
+			path: e.command,
+			spawnargs: e.args
+		});
+	}
+	function i(e, t) {
+		if (!n) return;
+		let r = e.emit;
+		e.emit = function(n, i) {
+			if (n === `exit`) {
+				let n = a(i, t);
+				if (n) return r.call(e, `error`, n);
+			}
+			return r.apply(e, arguments);
+		};
+	}
+	function a(e, t) {
+		return n && e === 1 && !t.file ? r(t.original, `spawn`) : null;
+	}
+	function o(e, t) {
+		return n && e === 1 && !t.file ? r(t.original, `spawnSync`) : null;
+	}
+	t.exports = {
+		hookChildProcess: i,
+		verifyENOENT: a,
+		verifyENOENTSync: o,
+		notFoundError: r
+	};
+})), H = w(((e, t) => {
+	let n = T(`child_process`), r = V(), i = ie();
+	function a(e, t, a) {
+		let o = r(e, t, a), s = n.spawn(o.command, o.args, o.options);
+		return i.hookChildProcess(s, o), s;
+	}
+	function o(e, t, a) {
+		let o = r(e, t, a), s = n.spawnSync(o.command, o.args, o.options);
+		return s.error = s.error || i.verifyENOENTSync(s.status, o), s;
+	}
+	t.exports = a, t.exports.spawn = a, t.exports.sync = o, t.exports._parse = r, t.exports._enoent = i;
+}))(), U = class extends Error {
+	result;
+	output;
+	get exitCode() {
+		if (this.result.exitCode !== null) return this.result.exitCode;
+	}
+	constructor(e, t) {
+		super(`Process exited with non-zero status (${e.exitCode})`), this.result = e, this.output = t;
+	}
+};
+const W = {
+	timeout: void 0,
+	persist: !1
+}, G = { windowsHide: !0 };
+function K(e, t) {
+	return {
+		command: (0,node_path__rspack_import_5.normalize)(e),
+		args: t ?? []
+	};
+}
+function q(e) {
+	let t = new AbortController();
+	for (let n of e) {
+		if (n.aborted) return t.abort(), n;
+		n.addEventListener(`abort`, () => {
+			t.abort(n.reason);
+		}, { signal: t.signal });
+	}
+	return t.signal;
+}
+async function J(e) {
+	let t = ``;
+	for await (let n of e) t += n.toString();
+	return t;
+}
+var Y = class {
+	_process;
+	_aborted = !1;
+	_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, t, n) {
+		this._options = {
+			...W,
+			...n
+		}, this._command = e, this._args = t ?? [], this._processClosed = new Promise((e) => {
+			this._resolveClose = e;
+		});
+	}
+	kill(e) {
+		return this._process?.kill(e) === !0;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get killed() {
+		return this._process?.killed === !0;
+	}
+	pipe(e, t, n) {
+		return ae(e, t, {
+			...n,
+			stdin: this
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		let e = this._process;
+		if (!e) return;
+		let t = [];
+		this._streamErr && t.push(this._streamErr), this._streamOut && t.push(this._streamOut);
+		let n = A(t), r = node_readline__rspack_import_7.createInterface({ input: n });
+		for await (let e of r) yield e.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 [t, n] = 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 r = {
+			stderr: n,
+			stdout: t,
+			exitCode: this.exitCode
+		};
+		if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new U(this, r);
+		return r;
+	}
+	then(e, t) {
+		return this._waitForOutput().then(e, t);
+	}
+	_streamOut;
+	_streamErr;
+	spawn() {
+		let e = (0,node_process__rspack_import_6.cwd)(), t = this._options, n = {
+			...G,
+			...t.nodeOptions
+		}, r = [];
+		this._resetState(), t.timeout !== void 0 && r.push(AbortSignal.timeout(t.timeout)), t.signal !== void 0 && r.push(t.signal), t.persist === !0 && (n.detached = !0), r.length > 0 && (n.signal = q(r)), n.env = k(e, n.env);
+		let { command: i, args: o } = K(this._command, this._args), s = (0, H._parse)(i, o, n), c = (0,node_child_process__rspack_import_4.spawn)(s.command, s.args, s.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), t.stdin !== void 0 && c.stdin && t.stdin.process) {
+			let { stdout: e } = t.stdin.process;
+			e && e.pipe(c.stdin);
+		}
+	}
+	_resetState() {
+		this._aborted = !1, 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 = !0;
+			return;
+		}
+		this._thrownError = e;
+	};
+	_onClose = () => {
+		this._resolveClose && this._resolveClose();
+	};
+};
+const X = (e, t, n) => {
+	let r = new Y(e, t, n);
+	return r.spawn(), r;
+}, ae = X;
+var oe = (0,_rolldown_runtime_mjs__rspack_import_8.t)({
+	detectPackageManager: () => $,
+	installDependencies: () => fe,
+	packageManagers: () => Q
+});
+async function se(e, t, n = {}) {
+	let r = g(e).split(`/`);
+	for (; r.length > 0;) {
+		let e = await t(r.join(`/`) || `/`);
+		if (e || !n.includeParentDirs) return e;
+		r.pop();
+	}
+}
+function ce(e) {
+	let t;
+	return () => (t === void 0 && (t = e().then((e) => (t = e, t))), t);
+}
+const Z = ce(async () => {
+	if (globalThis.process?.versions?.webcontainer) return !1;
+	try {
+		let { exitCode: e } = await X(`corepack`, [`--version`]);
+		return e === 0;
+	} catch {
+		return !1;
+	}
+});
+async function le(e, t, n = {}) {
+	let r = e !== `npm` && e !== `bun` && e !== `deno` && n.corepack !== !1 && await Z() ? [`corepack`, [e, ...t]] : [e, t], { exitCode: i, stdout: a, stderr: o } = await X(r[0], r[1], { nodeOptions: {
+		cwd: y(n.cwd || process.cwd()),
+		env: n.env,
+		stdio: n.silent ? `pipe` : `inherit`
+	} });
+	if (i !== 0) throw Error(`\`${r.flat().join(` `)}\` failed.${n.silent ? [
+		``,
+		a,
+		o
+	].join(`
+`) : ``}`);
+}
+async function ue(e = {}) {
+	let t = e.cwd || process.cwd(), n = {
+		...process.env,
+		...e.env
+	}, r = (typeof e.packageManager == `string` ? Q.find((t) => t.name === e.packageManager) : e.packageManager) || await $(e.cwd || process.cwd());
+	if (!r) throw Error(`No package manager auto-detected.`);
+	return {
+		cwd: t,
+		env: n,
+		silent: e.silent ?? !1,
+		packageManager: r,
+		dev: e.dev ?? !1,
+		workspace: e.workspace,
+		global: e.global ?? !1,
+		dry: e.dry ?? !1,
+		corepack: e.corepack ?? !0
+	};
+}
+function de(e) {
+	let [t, n] = (e || ``).split(`@`), [r, i] = n?.split(`+`) || [];
+	if (t && t !== `-` && /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(t)) return {
+		name: t,
+		version: r,
+		buildMeta: i
+	};
+	let a = (t || ``).replace(/\W+/g, ``);
+	return {
+		name: a,
+		version: r,
+		buildMeta: i,
+		warnings: [`Abnormal characters found in \`packageManager\` field, sanitizing from \`${t}\` to \`${a}\``]
+	};
+}
+const 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, t = {}) {
+	let i = await se(y(e || `.`), async (e) => {
+		if (!t.ignorePackageJSON) {
+			let t = _(e, `package.json`);
+			if ((0,node_fs__rspack_import_1.existsSync)(t)) {
+				let e = JSON.parse(await (0,node_fs_promises__rspack_import_2.readFile)(t, `utf8`));
+				if (e?.packageManager) {
+					let { name: t, version: n = `0.0.0`, buildMeta: r, warnings: i } = de(e.packageManager);
+					if (t) {
+						let e = n.split(`.`)[0], a = Q.find((n) => n.name === t && n.majorVersion === e) || Q.find((e) => e.name === t);
+						return {
+							name: t,
+							command: t,
+							version: n,
+							majorVersion: e,
+							buildMeta: r,
+							warnings: i,
+							files: a?.files,
+							lockFile: a?.lockFile
+						};
+					}
+				}
+			}
+			if ((0,node_fs__rspack_import_1.existsSync)(_(e, `deno.json`))) return Q.find((e) => e.name === `deno`);
+		}
+		if (!t.ignoreLockFile) {
+			for (let t of Q) if ([t.lockFile, t.files].flat().filter(Boolean).some((t) => (0,node_fs__rspack_import_1.existsSync)(y(e, t)))) return { ...t };
+		}
+	}, { includeParentDirs: t.includeParentDirs ?? !0 });
+	if (!i && !t.ignoreArgv) {
+		let e = process.argv[1];
+		if (e) {
+			for (let t of Q) if (RegExp(`[/\\\\]\\.?${t.command}`).test(e)) return t;
+		}
+	}
+	return i;
+}
+async function fe(e = {}) {
+	let t = await ue(e), n = e.frozenLockFile ? {
+		npm: [`ci`],
+		yarn: [`install`, `--immutable`],
+		bun: [`install`, `--frozen-lockfile`],
+		pnpm: [`install`, `--frozen-lockfile`],
+		deno: [`install`, `--frozen`]
+	}[t.packageManager.name] : [`install`];
+	return e.ignoreWorkspace && t.packageManager.name === `pnpm` && n.push(`--ignore-workspace`), t.dry || await le(t.packageManager.command, n, {
+		cwd: t.cwd,
+		silent: t.silent,
+		corepack: t.corepack
+	}), { exec: {
+		command: t.packageManager.command,
+		args: n
+	} };
+}
+
+
+
+},
+421(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  t: () => (__exportAll)
+});
+/* import */ var node_module__rspack_import_0 = __webpack_require__(8995);
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+
+
+
+},
+7170(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  downloadTemplate: () => (/* reexport */ downloadTemplate)
+});
+
+// UNUSED EXPORTS: startShell, registryProvider
+
+// EXTERNAL MODULE: ../../node_modules/giget/dist/_chunks/libs/nypm.mjs
+var nypm = __webpack_require__(292);
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __webpack_require__(3024);
+// EXTERNAL MODULE: external "node:fs/promises"
+var promises_ = __webpack_require__(1455);
+// EXTERNAL MODULE: external "node:stream"
+var external_node_stream_ = __webpack_require__(7075);
+// EXTERNAL MODULE: external "node:stream/promises"
+var external_node_stream_promises_ = __webpack_require__(6466);
+// EXTERNAL MODULE: external "node:child_process"
+var external_node_child_process_ = __webpack_require__(1421);
+// EXTERNAL MODULE: external "node:os"
+var external_node_os_ = __webpack_require__(8161);
+// EXTERNAL MODULE: external "node:util"
+var external_node_util_ = __webpack_require__(7975);
+// EXTERNAL MODULE: external "node:path"
+var external_node_path_ = __webpack_require__(6760);
+;// CONCATENATED MODULE: ../../node_modules/giget/dist/_chunks/giget.mjs
+
+
+
+
+
+
+
+
+
+//#region src/_utils.ts
+async function download(url, filePath, options = {}) {
+	const infoPath = filePath + ".json";
+	const info = JSON.parse(await (0,promises_.readFile)(infoPath, "utf8").catch(() => "{}"));
+	const etag = (await sendFetch(url, {
+		method: "HEAD",
+		headers: options.headers
+	}).catch(() => void 0))?.headers.get("etag");
+	if (info.etag === etag && (0,external_node_fs_.existsSync)(filePath)) return;
+	if (typeof etag === "string") info.etag = etag;
+	const response = await sendFetch(url, { headers: options.headers });
+	if (response.status >= 400) throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+	const stream = (0,external_node_fs_.createWriteStream)(filePath);
+	await (0,external_node_util_.promisify)(external_node_stream_.pipeline)(response.body, stream);
+	await (0,promises_.writeFile)(infoPath, JSON.stringify(info), "utf8");
+}
+const inputRegex = /^(?<repo>[-\w.]+\/[-\w.]+)(?<subdir>[^#]+)?(?<ref>#[-\w./@]+)?/;
+const expandedInputRegex = /^(?<repo>[-\w.]+(?:\/[-\w.]+)+?)(?:::(?<subdir>[^#]*))?(?<ref>#[-\w./@]+)?$/;
+function parseGitURI(input, options) {
+	const useExpanded = options?.expandRepo || input.includes("::");
+	const m = input.match(useExpanded ? expandedInputRegex : inputRegex)?.groups || {};
+	const subdir = useExpanded ? m.subdir ? "/" + m.subdir : "/" : m.subdir || "/";
+	return {
+		repo: m.repo || "",
+		subdir,
+		ref: m.ref ? m.ref.slice(1) : "main"
+	};
+}
+function debug(...args) {
+	if (process.env.DEBUG) console.debug("[giget]", ...args);
+}
+async function sendFetch(url, options = {}) {
+	if (options.headers?.["sec-fetch-mode"]) options.mode = options.headers["sec-fetch-mode"];
+	const res = await fetch(url, {
+		...options,
+		headers: normalizeHeaders(options.headers)
+	}).catch((error) => {
+		throw new Error(`Failed to download ${url}: ${error}`, { cause: error });
+	});
+	if (options.validateStatus && res.status >= 400) throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+	return res;
+}
+function cacheDirectory() {
+	const cacheDir = process.env.XDG_CACHE_HOME ? (0,nypm.a)(process.env.XDG_CACHE_HOME, "giget") : (0,nypm.a)((0,external_node_os_.homedir)(), ".cache/giget");
+	if (process.platform === "win32") {
+		const windowsCacheDir = (0,nypm.a)((0,external_node_os_.tmpdir)(), "giget");
+		if (!(0,external_node_fs_.existsSync)(windowsCacheDir) && (0,external_node_fs_.existsSync)(cacheDir)) try {
+			(0,external_node_fs_.renameSync)(cacheDir, windowsCacheDir);
+		} catch {}
+		return windowsCacheDir;
+	}
+	return cacheDir;
+}
+function normalizeHeaders(headers = {}) {
+	const normalized = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (!value) continue;
+		normalized[key.toLowerCase()] = value;
+	}
+	return normalized;
+}
+function currentShell() {
+	if (process.env.SHELL) return process.env.SHELL;
+	if (process.platform === "win32") return "cmd.exe";
+	return "/bin/bash";
+}
+function startShell(cwd) {
+	cwd = resolve$1(cwd);
+	const shell = currentShell();
+	console.info(`(experimental) Opening shell in ${relative(process.cwd(), cwd)}...`);
+	spawnSync(shell, [], {
+		cwd,
+		shell: true,
+		stdio: "inherit"
+	});
+}
+//#endregion
+//#region src/git.ts
+const git = (input, options) => {
+	const parsed = parseGitCloneURI(input);
+	return {
+		name: parsed.name,
+		version: parsed.subdir ? `${parsed.version || "default"}-${parsed.subdir.replaceAll("/", "-")}` : parsed.version,
+		tar: ({ auth } = {}) => _cloneAndTar(parsed, auth ?? options.auth)
+	};
+};
+function parseGitCloneURI(input, opts = {}) {
+	const cwd = opts.cwd ?? process.cwd();
+	let uri = input.replace(/#.*$/, "");
+	let pathSubdir;
+	if (/^[./]/.test(input)) uri = (0,nypm.a)(cwd, uri);
+	else if (/^https?:\/\//.test(uri)) {
+		const httpMatch = /^(https?:\/\/[^/]+)\/([\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(.+))?$/.exec(uri);
+		if (httpMatch) {
+			const [, origin, repo, rest] = httpMatch;
+			uri = `${origin}/${repo}`;
+			if (rest) pathSubdir = rest;
+		}
+	} else if (uri.includes("@")) {
+		const sshMatch = /^(.*?:[\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(.+))?$/.exec(uri);
+		if (sshMatch) {
+			const [, repoUri, rest] = sshMatch;
+			uri = repoUri;
+			if (rest) pathSubdir = rest;
+		}
+	} else {
+		const hostMap = {
+			"github:": "https://github.com/",
+			"gh:": "https://github.com/",
+			"gitlab:": "https://gitlab.com/",
+			"bitbucket:": "https://bitbucket.org/",
+			"sourcehut:": "https://git.sr.ht/~"
+		};
+		const host = /^(.+?:)/.exec(uri)?.at(1);
+		if (host && hostMap[host]) uri = uri.replace(host, hostMap[host]);
+		else if (!host) uri = `${(process.env.GIGET_GIT_HOST || "https://github.com/").replace(/\/$/, "")}/${uri}`;
+		const httpMatch = /^(https?:\/\/[^/]+\/~?[\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(.+))?$/.exec(uri);
+		if (httpMatch) {
+			const [, repoUri, rest] = httpMatch;
+			uri = repoUri;
+			if (rest) pathSubdir = rest;
+		}
+	}
+	const name = uri.replace(/^https?:\/\//, "").replace(/^.+@/, "").replace(/(\.git)?(#.*)?$/, "").replace(/^\W+/, "").replaceAll(/[:/]/g, "-");
+	const [version, hashSubdir] = /#(.+)$/.exec(input)?.at(1)?.split(":") ?? [];
+	const resolvedVersion = version || void 0;
+	const subdir = hashSubdir || pathSubdir;
+	return {
+		uri,
+		name,
+		...resolvedVersion && { version: resolvedVersion },
+		...subdir && { subdir }
+	};
+}
+async function _cloneAndTar(parsed, token) {
+	const tmpDir = await (0,promises_.mkdtemp)((0,external_node_path_.join)((0,external_node_os_.tmpdir)(), "giget-git-"));
+	if (token && /[\r\n]/.test(token)) throw new Error("Auth token must not contain newline characters");
+	const execEnv = {
+		...process.env,
+		GIT_TERMINAL_PROMPT: "0"
+	};
+	if (token) {
+		execEnv.GIT_CONFIG_COUNT = "1";
+		execEnv.GIT_CONFIG_KEY_0 = "http.extraHeader";
+		execEnv.GIT_CONFIG_VALUE_0 = `Authorization: Bearer ${token}`;
+	}
+	const execOpts = {
+		env: execEnv,
+		timeout: 6e4
+	};
+	const status = _createStatus();
+	const gitExec = (args) => _gitSpawn(args, execOpts, status);
+	const gitExecIn = (args) => _gitSpawn(args, {
+		...execOpts,
+		cwd: tmpDir
+	}, status);
+	try {
+		const cloneArgs = [
+			"clone",
+			"--progress",
+			"--depth",
+			"1"
+		];
+		if (parsed.subdir) cloneArgs.push("--filter=blob:none", "--sparse", "--no-checkout");
+		if (parsed.version) cloneArgs.push("--branch", parsed.version);
+		cloneArgs.push("--", parsed.uri, tmpDir);
+		try {
+			status.update("Cloning...");
+			await gitExec(cloneArgs);
+			status.update("Cloned.");
+		} catch (cloneError) {
+			if (!parsed.version) throw cloneError;
+			debug("Shallow clone failed, falling back to full clone:", cloneError);
+			status.update("Shallow clone failed, cloning...");
+			await (0,promises_.rm)(tmpDir, {
+				recursive: true,
+				force: true
+			});
+			await (0,promises_.mkdir)(tmpDir, { recursive: true });
+			await gitExecIn(["init"]);
+			await gitExecIn([
+				"remote",
+				"add",
+				"origin",
+				parsed.uri
+			]);
+			await gitExecIn(["fetch", "origin"]);
+			await gitExecIn(["checkout", parsed.version]);
+			status.update("Fetched.");
+		}
+		if (parsed.subdir) {
+			status.update(`Sparse checkout ${parsed.subdir}...`);
+			await gitExecIn([
+				"sparse-checkout",
+				"set",
+				parsed.subdir
+			]);
+			await gitExecIn(["checkout"]);
+		}
+		status.update("Packing...");
+		const tarDir = parsed.subdir ? (0,external_node_path_.join)(tmpDir, parsed.subdir) : tmpDir;
+		const { create } = await __webpack_require__.e(/* import() */ "316").then(__webpack_require__.bind(__webpack_require__, 5375)).then((n) => n.t);
+		status.done();
+		const stream = create({
+			gzip: true,
+			cwd: tarDir,
+			filter: (path) => !path.startsWith(".git/") && path !== ".git" && !path.startsWith("./.git/") && path !== "./.git"
+		}, ["."]).pipe(new external_node_stream_.PassThrough());
+		let cleaned = false;
+		const cleanup = () => {
+			if (cleaned) return;
+			cleaned = true;
+			(0,promises_.rm)(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		};
+		stream.on("end", cleanup);
+		stream.on("error", cleanup);
+		stream.on("close", cleanup);
+		return stream;
+	} catch (error) {
+		status.done();
+		await (0,promises_.rm)(tmpDir, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+const _spinnerFrames = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+function _gitSpawn(args, opts, status) {
+	return new Promise((resolve, reject) => {
+		const proc = (0,external_node_child_process_.spawn)("git", args, {
+			...opts,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		proc.stdout.resume();
+		let lastLine = "";
+		proc.stderr?.on("data", (chunk) => {
+			const str = chunk.toString();
+			for (const line of str.split(/[\r\n]/)) {
+				const clean = line.trim();
+				if (clean) lastLine = clean;
+			}
+			if (status) status.update(lastLine);
+		});
+		proc.on("close", (code) => {
+			if (code === 0) resolve(lastLine);
+			else reject(/* @__PURE__ */ new Error(`git ${args[0]} exited with code ${code}. Is git installed?`));
+		});
+		proc.on("error", (err) => {
+			if (err.code === "ENOENT") reject(/* @__PURE__ */ new Error("git is not installed or not found in PATH"));
+			else reject(err);
+		});
+	});
+}
+function _createStatus() {
+	if (!process.stderr.isTTY) return {
+		update(_text) {},
+		done() {}
+	};
+	let msg = "";
+	let frame = 0;
+	const render = () => {
+		const spinner = _spinnerFrames[frame % _spinnerFrames.length];
+		frame++;
+		process.stderr.write(`\x1B[2K\r\x1B[2m${spinner} ${msg}\x1B[0m`);
+	};
+	const interval = setInterval(render, 80);
+	return {
+		update(text) {
+			msg = text;
+			render();
+		},
+		done() {
+			clearInterval(interval);
+			process.stderr.write("\x1B[2K\r");
+		}
+	};
+}
+//#endregion
+//#region src/providers.ts
+const http = async (input, options) => {
+	if (input.endsWith(".json")) return await _httpJSON(input, options);
+	const url = new URL(input);
+	let name = (0,nypm.n)(url.pathname);
+	try {
+		const head = await sendFetch(url.href, {
+			method: "HEAD",
+			validateStatus: true,
+			headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 }
+		});
+		if ((head.headers.get("content-type") || "").includes("application/json")) return await _httpJSON(input, options);
+		const filename = head.headers.get("content-disposition")?.match(/filename="?(.+)"?/)?.[1];
+		if (filename) name = filename.split(".")[0];
+	} catch (error) {
+		debug(`Failed to fetch HEAD for ${url.href}:`, error);
+	}
+	return {
+		name: `${name}-${url.href.slice(0, 8)}`,
+		version: "",
+		subdir: "",
+		tar: url.href,
+		defaultDir: name,
+		headers: { Authorization: options.auth ? `Bearer ${options.auth}` : void 0 }
+	};
+};
+const _httpJSON = async (input, options) => {
+	const info = await (await sendFetch(input, {
+		validateStatus: true,
+		headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 }
+	})).json();
+	if (!info.tar || !info.name) throw new Error(`Invalid template info from ${input}. name or tar fields are missing!`);
+	return info;
+};
+const github = (input, options) => {
+	const parsed = parseGitURI(input);
+	const githubAPIURL = process.env.GIGET_GITHUB_URL || "https://api.github.com";
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: {
+			Authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+			Accept: "application/vnd.github+json",
+			"X-GitHub-Api-Version": "2022-11-28"
+		},
+		url: `${githubAPIURL.replace("api.github.com", "github.com")}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+		tar: `${githubAPIURL}/repos/${parsed.repo}/tarball/${parsed.ref}`
+	};
+};
+const giget_gitlab = (input, options) => {
+	const parsed = parseGitURI(input, { expandRepo: true });
+	const gitlab = process.env.GIGET_GITLAB_URL || "https://gitlab.com";
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: {
+			authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+			"sec-fetch-mode": "same-origin"
+		},
+		url: `${gitlab}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+		tar: `${gitlab}/${parsed.repo}/-/archive/${parsed.ref}.tar.gz`
+	};
+};
+const bitbucket = (input, options) => {
+	const parsed = parseGitURI(input);
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 },
+		url: `https://bitbucket.com/${parsed.repo}/src/${parsed.ref}${parsed.subdir}`,
+		tar: `https://bitbucket.org/${parsed.repo}/get/${parsed.ref}.tar.gz`
+	};
+};
+const sourcehut = (input, options) => {
+	const parsed = parseGitURI(input);
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 },
+		url: `https://git.sr.ht/~${parsed.repo}/tree/${parsed.ref}/item${parsed.subdir}`,
+		tar: `https://git.sr.ht/~${parsed.repo}/archive/${parsed.ref}.tar.gz`
+	};
+};
+const providers = {
+	http,
+	https: http,
+	git,
+	github,
+	gh: github,
+	gitlab: giget_gitlab,
+	bitbucket,
+	sourcehut
+};
+//#endregion
+//#region src/registry.ts
+const DEFAULT_REGISTRY = "https://raw.githubusercontent.com/unjs/giget/main/templates";
+const registryProvider = (registryEndpoint = DEFAULT_REGISTRY, options = {}) => {
+	return (async (input) => {
+		const start = Date.now();
+		const registryURL = `${registryEndpoint}/${input}.json`;
+		const result = await sendFetch(registryURL, { headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 } });
+		if (result.status >= 400) throw new Error(`Failed to download ${input} template info from ${registryURL}: ${result.status} ${result.statusText}`);
+		const info = await result.json();
+		if (!info.tar || !info.name) throw new Error(`Invalid template info from ${registryURL}. name or tar fields are missing!`);
+		debug(`Fetched ${input} template info from ${registryURL} in ${Date.now() - start}ms`);
+		return info;
+	});
+};
+//#endregion
+//#region src/giget.ts
+const sourceProtoRe = /^([\w+-.]+):/;
+async function downloadTemplate(input, options = {}) {
+	options.registry = process.env.GIGET_REGISTRY ?? options.registry;
+	options.auth = process.env.GIGET_AUTH ?? options.auth;
+	const registry = options.registry === false ? void 0 : registryProvider(options.registry, { auth: options.auth });
+	let providerName = options.provider || (registry ? "registry" : "github");
+	let source = input;
+	const sourceProviderMatch = input.match(sourceProtoRe);
+	if (sourceProviderMatch) {
+		providerName = sourceProviderMatch[1];
+		source = input.slice(sourceProviderMatch[0].length);
+		if (providerName === "http" || providerName === "https") source = input;
+	}
+	if (providerName.endsWith("+git")) {
+		source = `${providerName.slice(0, -4)}:${source}`;
+		providerName = "git";
+	}
+	const provider = options.providers?.[providerName] || providers[providerName] || registry;
+	if (!provider) throw new Error(`Unsupported provider: ${providerName}`);
+	const template = await Promise.resolve().then(() => provider(source, { auth: options.auth })).catch((error) => {
+		throw new Error(`Failed to download template from ${providerName}: ${error.message}`);
+	});
+	if (!template) throw new Error(`Failed to resolve template from ${providerName}`);
+	template.name = (template.name || "template").replace(/[^\da-z-]/gi, "-");
+	template.defaultDir = (template.defaultDir || template.name).replace(/[^\da-z-]/gi, "-");
+	const tarPath = (0,nypm.a)((0,nypm.a)(cacheDirectory(), providerName, template.name), (template.version || template.name) + ".tar.gz");
+	if (options.preferOffline && (0,external_node_fs_.existsSync)(tarPath)) options.offline = true;
+	if (!options.offline) {
+		await (0,promises_.mkdir)((0,nypm.r)(tarPath), { recursive: true });
+		const s = Date.now();
+		if (typeof template.tar === "function") {
+			const tarFn = template.tar;
+			await (async () => {
+				const stream = await tarFn({ auth: options.auth });
+				await (0,external_node_stream_promises_.pipeline)(stream instanceof external_node_stream_.Readable ? stream : external_node_stream_.Readable.fromWeb(stream), (0,external_node_fs_.createWriteStream)(tarPath));
+			})().catch((error) => {
+				if (!(0,external_node_fs_.existsSync)(tarPath)) throw error;
+				debug("Download error. Using cached version:", error);
+				options.offline = true;
+			});
+		} else await download(template.tar, tarPath, { headers: {
+			Authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+			...normalizeHeaders(template.headers)
+		} }).catch((error) => {
+			if (!(0,external_node_fs_.existsSync)(tarPath)) throw error;
+			debug("Download error. Using cached version:", error);
+			options.offline = true;
+		});
+		debug(`Downloaded to ${tarPath} in ${Date.now() - s}ms`);
+	}
+	if (!(0,external_node_fs_.existsSync)(tarPath)) throw new Error(`Tarball not found: ${tarPath} (offline: ${options.offline})`);
+	const extractPath = (0,nypm.a)((0,nypm.a)(options.cwd || "."), options.dir || template.defaultDir);
+	if (options.forceClean) await (0,promises_.rm)(extractPath, {
+		recursive: true,
+		force: true
+	});
+	if (!options.force && (0,external_node_fs_.existsSync)(extractPath) && (0,external_node_fs_.readdirSync)(extractPath).length > 0) throw new Error(`Destination ${extractPath} already exists.`);
+	await (0,promises_.mkdir)(extractPath, { recursive: true });
+	const s = Date.now();
+	const subdir = template.subdir?.replace(/^\//, "") || "";
+	const { extract } = await __webpack_require__.e(/* import() */ "316").then(__webpack_require__.bind(__webpack_require__, 5375)).then((n) => n.t);
+	await extract({
+		file: tarPath,
+		cwd: extractPath,
+		onReadEntry(entry) {
+			entry.path = entry.path.split("/").splice(1).join("/");
+			if (subdir) if (entry.path.startsWith(subdir + "/")) entry.path = entry.path.slice(subdir.length);
+			else entry.path = "";
+		}
+	});
+	debug(`Extracted to ${extractPath} in ${Date.now() - s}ms`);
+	if (options.install) {
+		debug("Installing dependencies...");
+		const { installDependencies } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 292)).then((n) => n.t);
+		await installDependencies({
+			cwd: extractPath,
+			silent: options.silent,
+			...typeof options.install === "object" ? options.install : {}
+		});
+	}
+	return {
+		...template,
+		source,
+		dir: extractPath
+	};
+}
+//#endregion
+
+
+;// CONCATENATED MODULE: ../../node_modules/giget/dist/index.mjs
+
+
+
+
+},
+
+};
+
+//# sourceMappingURL=511.js.map