@voidzero-dev/vite-plus-core 0.1.22 → 0.1.24

package/dist/tsdown/main-nVIFtu2j.js

@@ -0,0 +1,938 @@
+import { createRequire } from "node:module";
+import process$1, { cwd } from "node:process";
+import readline from "node:readline";
+import { isatty } from "node:tty";
+import { formatWithOptions, inspect } from "node:util";
+import { spawn } from "node:child_process";
+import { basename, delimiter, dirname, normalize, resolve } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { PassThrough } from "node:stream";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+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;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.22.1_@arethetypeswrong+core@0.18.2_@tsdown+css@0.22.1_@tsdown+exe@0.22.1_@type_b2f732f99208225f009f13478ba95350/node_modules/tsdown/dist/general-Cp4NiJNK.mjs
+const picomatch = createRequire(import.meta.url)("./npm_entry_picomatch.cjs");
+function toArray(val, defaultValue) {
+	if (Array.isArray(val)) return val;
+	else if (val == null) {
+		if (defaultValue) return [defaultValue];
+		return [];
+	} else return [val];
+}
+function resolveComma(arr) {
+	return arr.flatMap((format) => format.split(","));
+}
+function resolveRegex(str) {
+	if (typeof str === "string" && str.length > 2 && str[0] === "/" && str.at(-1) === "/") return new RegExp(str.slice(1, -1));
+	return str;
+}
+function slash(string) {
+	return string.replaceAll("\\", "/");
+}
+const noop = (v) => v;
+function matchPattern(id, patterns) {
+	return patterns.some((pattern) => {
+		if (pattern instanceof RegExp) {
+			pattern.lastIndex = 0;
+			return pattern.test(id);
+		}
+		return id === pattern || picomatch(pattern)(id);
+	});
+}
+function pkgExists(moduleName) {
+	try {
+		import.meta.resolve(moduleName);
+		return true;
+	} catch {}
+	return false;
+}
+async function importWithError(moduleName) {
+	try {
+		return await import(moduleName);
+	} catch (error) {
+		throw new Error(`Failed to import module "${moduleName}". Please ensure it is installed.`, { cause: error });
+	}
+}
+function promiseWithResolvers() {
+	let resolve;
+	return {
+		promise: new Promise((res) => {
+			resolve = res;
+		}),
+		resolve
+	};
+}
+function debounce(fn, delay) {
+	let timer;
+	const debounced = (...args) => {
+		clearTimeout(timer);
+		timer = setTimeout(() => fn(...args), delay);
+	};
+	debounced.cancel = () => clearTimeout(timer);
+	return debounced;
+}
+const { Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible, link, bold, dim, italic, underline, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let e, r, { defineProperty: t, setPrototypeOf: n, create: l, keys: o } = Object, i = "", { round: s, max: f } = Math, u = (e) => {
+		let r = /([a-f\d]{3,6})/i.exec(e)?.[1], t = r?.length, n = parseInt(6 ^ t ? 3 ^ t ? "0" : r[0] + r[0] + r[1] + r[1] + r[2] + r[2] : r, 16);
+		return [
+			n >> 16 & 255,
+			n >> 8 & 255,
+			255 & n
+		];
+	}, a = (e, r, t) => e ^ r || r ^ t ? 16 + 36 * s(e / 51) + 6 * s(r / 51) + s(t / 51) : 8 > e ? 16 : e > 248 ? 231 : s(24 * (e - 8) / 247) + 232, c = (e) => {
+		let r, t, n, l, o;
+		return 8 > e ? 30 + e : 16 > e ? 82 + e : (232 > e ? (o = (e -= 16) % 36, r = (e / 36 | 0) / 5, t = (o / 6 | 0) / 5, n = o % 6 / 5) : r = t = n = (10 * (e - 232) + 8) / 255, l = 2 * f(r, t, n), l ? 30 + (s(n) << 2 | s(t) << 1 | s(r)) + (2 ^ l ? 0 : 60) : 30);
+	}, g = {
+		open: i,
+		close: i
+	}, b = 39, d = 49, p = {}, $ = ({ p: e }, { open: t = "", close: l = "", f: o }) => {
+		let s = (e, ...r) => {
+			if (!e) {
+				if (t && t === l) return t;
+				if ((e ?? i) === i) return i;
+			}
+			let n, f = s.p, u = f.o, a = f.c, c = o ? o(e, ...r) : e.raw ? String.raw({ raw: e }, ...r) : i + e;
+			if (c.includes("\x1B")) for (; f; f = f.p) {
+				let { t: e, l: r } = f, t = r.length, l = i, o = 0;
+				if (t) for (; ~(n = c.indexOf(r, o)); o = n + t) l += c.slice(o, n) + e;
+				c = l + c.slice(o);
+			}
+			return u + (c.includes("\n") ? c.replace(/(\r?\n)/g, a + "$1" + u) : c) + a;
+		}, f = t, u = l;
+		return e && (f = e.o + t, u = l + e.c), n(s, r), s.p = {
+			t,
+			l,
+			o: s.open = f,
+			c: s.close = u,
+			p: e
+		}, s;
+	};
+	const h = new function s(f = globalThis) {
+		let h, y, m = "number" == typeof f ? f : ((r) => {
+			let t = r.process ?? {}, n = t.argv ?? [], l = t.env ?? {}, i = 0;
+			try {
+				i = ((r, t, n) => (e = t.TERM, {
+					"24bit": 3,
+					truecolor: 3,
+					ansi256: 2,
+					ansi: 1
+				}[t.COLORTERM] || (t.CI ? /,GITHUB/.test(n) ? 3 : 1 : (t.PM2_HOME || /edge/.test(t.NEXT_RUNTIME) || r.stdout?.isTTY) && "dumb" !== e ? "win32" === r.platform ? 3 : /-256/.test(e) ? 2 : 1 : 0)))(t, l, "," + o(l).join(","));
+			} catch (e) {
+				l = {};
+			}
+			let s, f = i || 1, u = "FORCE_COLOR", a = {
+				false: 0,
+				0: 0,
+				1: 1,
+				2: 2,
+				3: 3
+			}[l[u]] ?? f, c = -1;
+			for (s of n) /^--color=?(true|always)?$/.test(s) && (c = f), /^--(no-color|color=(false|never))$/.test(s) && (c = 0);
+			return r.window?.chrome ? 3 : u in l ? a : ~c ? c : l.NO_COLOR ? 0 : i;
+		})(f), w = {
+			Ansis: s,
+			level: m,
+			isSupported: () => v,
+			strip: (e) => e.replace(/[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, i),
+			extend(e) {
+				for (let r in e) {
+					let t = e[r], n = (typeof t)[0];
+					"s" === n && (O(B(r), I(...u(t))), t = H(...u(t))), O(r, t, "f" === n);
+				}
+				return n(w, r = l({}, p)), w;
+			}
+		}, O = (e, r, n) => {
+			p[e] = { get() {
+				let l = n ? (...e) => $(this, r(...e)) : $(this, r);
+				return t(this, e, { value: l }), l;
+			} };
+		}, v = m > 0, _ = (e, r) => v ? {
+			open: `[${e}m`,
+			close: `[${r}m`
+		} : g, k = (e) => (r) => e(...u(r)), x = (e, r) => (t, n, l) => _(`${e}8;2;${t};${n};${l}`, r), R = (e) => (r, t, n) => e(a(r, t, n)), A = (e, r) => (t, n, l) => _(c(a(t, n, l)) + e, r), B = (e) => "bg" + e[0].toUpperCase() + e.slice(1), C = "Bright", H = x(3, b), I = x(4, d), P = (e) => _("38;5;" + e, b), S = (e) => _("48;5;" + e, d);
+		return 2 === m ? (H = R(P), I = R(S)) : 1 === m && (H = A(0, b), I = A(10, d), P = (e) => _(c(e), b), S = (e) => _(c(e) + 10, d)), y = {
+			fg: P,
+			bg: S,
+			rgb: H,
+			bgRgb: I,
+			hex: k(H),
+			bgHex: k(I),
+			visible: g,
+			reset: _(0, 0),
+			bold: _(1, 22),
+			dim: _(2, 22),
+			italic: _(3, 23),
+			underline: _(4, 24),
+			inverse: _(7, 27),
+			hidden: _(8, 28),
+			strikethrough: _(9, 29),
+			link: { f: (e, r = e) => v ? `]8;;${e}${r}]8;;` : r != e ? `${r} (​${e}​)` : e }
+		}, "gray,black,red,green,yellow,blue,magenta,cyan,white".split(",").map(((e, r) => {
+			h = B(e), r ? (y[e + C] = _(89 + r, b), y[h + C] = _(99 + r, d)) : r = 61, y[e] = _(29 + r, b), y[h] = _(39 + r, d);
+		})), w.extend(y);
+	}();
+	module.exports = h.default = h;
+})))(), 1)).default;
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.22.1_@arethetypeswrong+core@0.18.2_@tsdown+css@0.22.1_@tsdown+exe@0.22.1_@type_b2f732f99208225f009f13478ba95350/node_modules/tsdown/dist/logger-BxuhTmAE.mjs
+const LogLevels = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3
+};
+function format(msgs) {
+	return msgs.filter((arg) => arg !== void 0 && arg !== false).join(" ");
+}
+function clearScreen() {
+	const repeatCount = process$1.stdout.rows - 2;
+	const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+	console.info(blank);
+	readline.cursorTo(process$1.stdout, 0, 0);
+	readline.clearScreenDown(process$1.stdout);
+}
+const warnedMessages = /* @__PURE__ */ new Set();
+function createLogger(level = "info", options = {}) {
+	const resolvedOptions = {
+		allowClearScreen: true,
+		failOnWarn: false,
+		console: globalThis.console,
+		...options
+	};
+	const { allowClearScreen, console, customLogger, failOnWarn } = resolvedOptions;
+	if (customLogger) return customLogger;
+	function output(type, msg) {
+		if (LogLevels[logger.level] < LogLevels[type]) return;
+		console[type === "info" ? "log" : type](msg);
+	}
+	const clear = allowClearScreen && process$1.stdout.isTTY && !process$1.env.CI ? clearScreen : () => {};
+	const isWindowsTerminal = !!process$1.env.WT_SESSION;
+	const emojiDivier = " ".repeat(isWindowsTerminal ? 2 : 1);
+	const logger = {
+		level,
+		options: resolvedOptions,
+		info(...msgs) {
+			output("info", `${blue`ℹ`}${emojiDivier}${format(msgs)}`);
+		},
+		warn(...msgs) {
+			if (failOnWarn) return this.error(...msgs);
+			const message = format(msgs);
+			warnedMessages.add(message);
+			output("warn", `${bold(yellow`warn:`)} ${message}`);
+		},
+		warnOnce(...msgs) {
+			const message = format(msgs);
+			if (failOnWarn) return this.error(...msgs);
+			if (warnedMessages.has(message)) return;
+			warnedMessages.add(message);
+			output("warn", `${bold(yellow`warn:`)} ${message}`);
+		},
+		error(...msgs) {
+			output("error", `${bold(red`error:`)} ${format(msgs).replace(/^([A-Za-z]*Error):\s*/, "")}`);
+			process$1.exitCode = 1;
+		},
+		success(...msgs) {
+			output("info", `${green`✔`}${emojiDivier}${format(msgs)}`);
+		},
+		clearScreen(type) {
+			if (LogLevels[logger.level] >= LogLevels[type]) clear();
+		}
+	};
+	return logger;
+}
+const globalLogger = createLogger();
+function getNameLabel(ansis, name) {
+	if (!name) return void 0;
+	return ansis(`[${name}]`);
+}
+function prettyFormat(format) {
+	const formatColor = format === "es" ? blue : format === "cjs" ? yellow : noop;
+	let formatText;
+	switch (format) {
+		case "es":
+			formatText = "ESM";
+			break;
+		default:
+			formatText = format.toUpperCase();
+			break;
+	}
+	return formatColor(`[${formatText}]`);
+}
+const colors$1 = /* @__PURE__ */ new Map();
+function generateColor(name = "default") {
+	if (colors$1.has(name)) return colors$1.get(name);
+	let color;
+	if (name === "default") color = blue;
+	else {
+		let hash = 0;
+		for (let i = 0; i < name.length; i++) hash = name.charCodeAt(i) + ((hash << 5) - hash);
+		color = rgb(...hslToRgb(hash % 360, 35, 55));
+	}
+	colors$1.set(name, color);
+	return color;
+}
+function hslToRgb(h, s, l) {
+	h = h % 360;
+	h /= 360;
+	s /= 100;
+	l /= 100;
+	let r, g, b;
+	if (s === 0) r = g = b = l;
+	else {
+		const q = l < .5 ? l * (1 + s) : l + s - l * s;
+		const p = 2 * l - q;
+		r = hue2rgb(p, q, h + 1 / 3);
+		g = hue2rgb(p, q, h);
+		b = hue2rgb(p, q, h - 1 / 3);
+	}
+	return [
+		Math.max(0, Math.round(r * 255)),
+		Math.max(0, Math.round(g * 255)),
+		Math.max(0, Math.round(b * 255))
+	];
+}
+function hue2rgb(p, q, t) {
+	if (t < 0) t += 1;
+	if (t > 1) t -= 1;
+	if (t < 1 / 6) return p + (q - p) * 6 * t;
+	if (t < 1 / 2) return q;
+	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+	return p;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/obug@2.1.1/node_modules/obug/dist/core.js
+function coerce(value) {
+	if (value instanceof Error) return value.stack || value.message;
+	return value;
+}
+function selectColor(colors, namespace) {
+	let hash = 0;
+	for (let i = 0; i < namespace.length; i++) {
+		hash = (hash << 5) - hash + namespace.charCodeAt(i);
+		hash |= 0;
+	}
+	return colors[Math.abs(hash) % colors.length];
+}
+function matchesTemplate(search, template) {
+	let searchIndex = 0;
+	let templateIndex = 0;
+	let starIndex = -1;
+	let matchIndex = 0;
+	while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
+		starIndex = templateIndex;
+		matchIndex = searchIndex;
+		templateIndex++;
+	} else {
+		searchIndex++;
+		templateIndex++;
+	}
+	else if (starIndex !== -1) {
+		templateIndex = starIndex + 1;
+		matchIndex++;
+		searchIndex = matchIndex;
+	} else return false;
+	while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
+	return templateIndex === template.length;
+}
+function humanize(value) {
+	if (value >= 1e3) return `${(value / 1e3).toFixed(1)}s`;
+	return `${value}ms`;
+}
+let globalNamespaces = "";
+function namespaces() {
+	return globalNamespaces;
+}
+function createDebug$1(namespace, options) {
+	let prevTime;
+	let enableOverride;
+	let namespacesCache;
+	let enabledCache;
+	const debug = (...args) => {
+		if (!debug.enabled) return;
+		const curr = Date.now();
+		const diff = curr - (prevTime || curr);
+		prevTime = curr;
+		args[0] = coerce(args[0]);
+		if (typeof args[0] !== "string") args.unshift("%O");
+		let index = 0;
+		args[0] = args[0].replace(/%([a-z%])/gi, (match, format) => {
+			if (match === "%%") return "%";
+			index++;
+			const formatter = options.formatters[format];
+			if (typeof formatter === "function") {
+				const value = args[index];
+				match = formatter.call(debug, value);
+				args.splice(index, 1);
+				index--;
+			}
+			return match;
+		});
+		options.formatArgs.call(debug, diff, args);
+		debug.log(...args);
+	};
+	debug.extend = function(namespace$1, delimiter = ":") {
+		return createDebug$1(this.namespace + delimiter + namespace$1, {
+			useColors: this.useColors,
+			color: this.color,
+			formatArgs: this.formatArgs,
+			formatters: this.formatters,
+			inspectOpts: this.inspectOpts,
+			log: this.log,
+			humanize: this.humanize
+		});
+	};
+	Object.assign(debug, options);
+	debug.namespace = namespace;
+	Object.defineProperty(debug, "enabled", {
+		enumerable: true,
+		configurable: false,
+		get: () => {
+			if (enableOverride != null) return enableOverride;
+			if (namespacesCache !== globalNamespaces) {
+				namespacesCache = globalNamespaces;
+				enabledCache = enabled(namespace);
+			}
+			return enabledCache;
+		},
+		set: (v) => {
+			enableOverride = v;
+		}
+	});
+	return debug;
+}
+let names = [];
+let skips = [];
+function enable$1(namespaces$1) {
+	globalNamespaces = namespaces$1;
+	names = [];
+	skips = [];
+	const split = globalNamespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+	for (const ns of split) if (ns[0] === "-") skips.push(ns.slice(1));
+	else names.push(ns);
+}
+function enabled(name) {
+	for (const skip of skips) if (matchesTemplate(name, skip)) return false;
+	for (const ns of names) if (matchesTemplate(name, ns)) return true;
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/obug@2.1.1/node_modules/obug/dist/node.js
+const colors = process.stderr.getColorDepth && process.stderr.getColorDepth() > 2 ? [
+	20,
+	21,
+	26,
+	27,
+	32,
+	33,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	56,
+	57,
+	62,
+	63,
+	68,
+	69,
+	74,
+	75,
+	76,
+	77,
+	78,
+	79,
+	80,
+	81,
+	92,
+	93,
+	98,
+	99,
+	112,
+	113,
+	128,
+	129,
+	134,
+	135,
+	148,
+	149,
+	160,
+	161,
+	162,
+	163,
+	164,
+	165,
+	166,
+	167,
+	168,
+	169,
+	170,
+	171,
+	172,
+	173,
+	178,
+	179,
+	184,
+	185,
+	196,
+	197,
+	198,
+	199,
+	200,
+	201,
+	202,
+	203,
+	204,
+	205,
+	206,
+	207,
+	208,
+	209,
+	214,
+	215,
+	220,
+	221
+] : [
+	6,
+	2,
+	3,
+	4,
+	5,
+	1
+];
+const inspectOpts = Object.keys(process.env).filter((key) => /^debug_/i.test(key)).reduce((obj, key) => {
+	const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, k) => k.toUpperCase());
+	let value = process.env[key];
+	const lowerCase = typeof value === "string" && value.toLowerCase();
+	if (value === "null") value = null;
+	else if (lowerCase === "yes" || lowerCase === "on" || lowerCase === "true" || lowerCase === "enabled") value = true;
+	else if (lowerCase === "no" || lowerCase === "off" || lowerCase === "false" || lowerCase === "disabled") value = false;
+	else value = Number(value);
+	obj[prop] = value;
+	return obj;
+}, {});
+function useColors() {
+	return "colors" in inspectOpts ? Boolean(inspectOpts.colors) : isatty(process.stderr.fd);
+}
+function getDate() {
+	if (inspectOpts.hideDate) return "";
+	return `${(/* @__PURE__ */ new Date()).toISOString()} `;
+}
+function formatArgs(diff, args) {
+	const { namespace: name, useColors: useColors$1 } = this;
+	if (useColors$1) {
+		const c = this.color;
+		const colorCode = `\u001B[3${c < 8 ? c : `8;5;${c}`}`;
+		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+		args[0] = prefix + args[0].split("\n").join(`\n${prefix}`);
+		args.push(`${colorCode}m+${this.humanize(diff)}\u001B[0m`);
+	} else args[0] = `${getDate()}${name} ${args[0]}`;
+}
+function log(...args) {
+	process.stderr.write(`${formatWithOptions(this.inspectOpts, ...args)}\n`);
+}
+const defaultOptions = {
+	useColors: useColors(),
+	formatArgs,
+	formatters: {
+		o(v) {
+			this.inspectOpts.colors = this.useColors;
+			return inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+		},
+		O(v) {
+			this.inspectOpts.colors = this.useColors;
+			return inspect(v, this.inspectOpts);
+		}
+	},
+	inspectOpts,
+	log,
+	humanize
+};
+function createDebug(namespace, options) {
+	var _ref;
+	const color = (_ref = options && options.color) !== null && _ref !== void 0 ? _ref : selectColor(colors, namespace);
+	return createDebug$1(namespace, Object.assign(defaultOptions, { color }, options));
+}
+function save(namespaces$1) {
+	if (namespaces$1) process.env.DEBUG = namespaces$1;
+	else delete process.env.DEBUG;
+}
+function enable(namespaces$1) {
+	save(namespaces$1);
+	enable$1(namespaces$1);
+}
+enable$1(process.env.DEBUG || "");
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.22.1_@arethetypeswrong+core@0.18.2_@tsdown+css@0.22.1_@tsdown+exe@0.22.1_@type_b2f732f99208225f009f13478ba95350/node_modules/tsdown/dist/debug-CiHXNOc4.mjs
+var version = "0.22.1";
+const debugLog = createDebug("tsdown:debug");
+function enableDebug(debug) {
+	if (!debug) return;
+	let namespace;
+	if (debug === true) namespace = "tsdown:*";
+	else namespace = resolveComma(toArray(debug)).map((v) => `tsdown:${v}`).join(",");
+	const ns = namespaces();
+	if (ns) namespace += `,${ns}`;
+	enable(namespace);
+	debugLog("Debugging enabled", namespace);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/tinyexec@1.2.4/node_modules/tinyexec/dist/main.mjs
+const h = /^path$/i;
+const g = {
+	key: "PATH",
+	value: ""
+};
+function _(e) {
+	for (const t in e) {
+		if (!Object.prototype.hasOwnProperty.call(e, t) || !h.test(t)) continue;
+		const n = e[t];
+		if (!n) return g;
+		return {
+			key: t,
+			value: n
+		};
+	}
+	return g;
+}
+function v(e, t) {
+	const n = t.value.split(delimiter);
+	const r = [];
+	let o = e;
+	let c;
+	do {
+		r.push(resolve(o, "node_modules", ".bin"));
+		c = o;
+		o = dirname(o);
+	} while (o !== c);
+	r.push(dirname(process.execPath));
+	const l = r.concat(n).join(delimiter);
+	return {
+		key: t.key,
+		value: l
+	};
+}
+function y(e, t, n = true) {
+	const r = {
+		...process.env,
+		...t
+	};
+	if (!n) return r;
+	const i = v(e, _(r));
+	r[i.key] = i.value;
+	return r;
+}
+const b = (e) => {
+	let t = e.length;
+	const n = new PassThrough();
+	const r = () => {
+		if (--t === 0) n.end();
+	};
+	for (const t of e) pipeline(t, n, { end: false }).then(r).catch(r);
+	return n;
+};
+const x = /([()\][%!^"`<>&|;, *?])/g;
+const S = /^#!\s*(.+)/;
+const C = /\.(?:com|exe)$/i;
+const w = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+const T = process.platform === "win32";
+const E = [
+	".EXE",
+	".CMD",
+	".BAT",
+	".COM"
+];
+/**
+* Normalizes the command and arguments to work cross-platform.
+* On Windows, this basically handles things like shebangs, calling
+* `node_modules/.bin` commands, and escaping meta characters.
+* On other platforms, it just returns the command and arguments as-is.
+*/
+function D(e, t = [], n = {}) {
+	if (n.shell === true || !T) return {
+		command: e,
+		args: t,
+		options: n
+	};
+	let i = O(e, n);
+	let a = null;
+	if (i !== null) {
+		const e = 150;
+		const t = Buffer.alloc(e);
+		let n = null;
+		try {
+			n = openSync(i, "r");
+			readSync(n, t, 0, e, 0);
+		} catch {} finally {
+			if (n !== null) closeSync(n);
+		}
+		const o = t.toString().match(S);
+		if (o !== null) {
+			const e = o[1].trim();
+			const t = e.indexOf(" ");
+			const n = t !== -1 ? e.slice(0, t) : e;
+			const i = t !== -1 ? e.slice(t + 1) : "";
+			const s = basename(n);
+			a = s === "env" ? i || null : s;
+		}
+	}
+	if (a !== null && i !== null) {
+		t = [i, ...t];
+		e = a;
+		i = O(e, n);
+	}
+	if (i === null || !C.test(i)) {
+		const r = i !== null && w.test(i);
+		e = normalize(e);
+		e = e.replace(x, "^$1");
+		t = t.map((e) => {
+			e = e.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+			e = e.replace(/(?=(\\+?)?)\1$/, "$1$1");
+			e = `"${e}"`;
+			e = e.replace(x, "^$1");
+			if (r) e = e.replace(x, "^$1");
+			return e;
+		});
+		t = [
+			"/d",
+			"/s",
+			"/c",
+			`"${[e, ...t].join(" ")}"`
+		];
+		e = n.env?.comspec ?? "cmd.exe";
+		n = {
+			...n,
+			windowsVerbatimArguments: true
+		};
+	}
+	return {
+		command: e,
+		args: t,
+		options: n
+	};
+}
+/**
+* Resolves the command to an absolute path if possible.
+* Handles things like traversing PATH and adding extensions from PATHEXT
+*/
+function O(e, t) {
+	const r = (t.cwd ?? cwd()).toString();
+	const a = t.env ?? process.env;
+	const o = _(a).value;
+	const c = e.includes("/") || e.includes("\\") ? [""] : [r, ...o.split(delimiter)];
+	const l = a.PATHEXT ? a.PATHEXT.split(delimiter) : E;
+	if (e.includes(".") && l[0] !== "") l.unshift("");
+	for (const t of c) {
+		const n = resolve(r, t.startsWith("\"") && t.endsWith("\"") && t.length > 1 ? t.slice(1, -1) : t, e);
+		for (const e of l) {
+			const t = n + e;
+			try {
+				if (statSync(t).isFile()) return t;
+			} catch {}
+		}
+	}
+	return null;
+}
+var k = 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 j = {
+	timeout: void 0,
+	persist: false
+};
+const N = { windowsHide: true };
+function P(e) {
+	const t = new AbortController();
+	for (const n of e) {
+		if (n.aborted) {
+			t.abort();
+			return n;
+		}
+		const e = () => {
+			t.abort(n.reason);
+		};
+		n.addEventListener("abort", e, { signal: t.signal });
+	}
+	return t.signal;
+}
+async function F(e) {
+	let t = "";
+	try {
+		for await (const n of e) t += n.toString();
+	} catch {}
+	return t;
+}
+var I = 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, t, n) {
+		this._options = {
+			...j,
+			...n
+		};
+		this._command = e;
+		this._args = t ?? [];
+		this._processClosed = new Promise((e) => {
+			this._resolveClose = e;
+		});
+	}
+	kill(e) {
+		return this._process?.kill(e) === true;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get killed() {
+		return this._process?.killed === true;
+	}
+	pipe(e, t, n) {
+		return z(e, t, {
+			...n,
+			stdin: this
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		const e = this._process;
+		if (!e) return;
+		const t = [];
+		if (this._streamErr) t.push(this._streamErr);
+		if (this._streamOut) t.push(this._streamOut);
+		const n = b(t);
+		const r = readline.createInterface({ input: n });
+		for await (const e of r) yield e.toString();
+		await this._processClosed;
+		e.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new k(this);
+	}
+	async _waitForOutput() {
+		const e = this._process;
+		if (!e) throw new Error("No process was started");
+		const [t, n] = await Promise.all([this._streamOut ? F(this._streamOut) : "", this._streamErr ? F(this._streamErr) : ""]);
+		await this._processClosed;
+		const { stdin: r } = this._options;
+		if (r && typeof r !== "string") await r;
+		e.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		const i = {
+			stderr: n,
+			stdout: t,
+			exitCode: this.exitCode
+		};
+		if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new k(this, i);
+		return i;
+	}
+	then(e, t) {
+		return this._waitForOutput().then(e, t);
+	}
+	_streamOut;
+	_streamErr;
+	spawn() {
+		const t = cwd();
+		const r = this._options;
+		const i = {
+			...N,
+			...r.nodeOptions
+		};
+		const a = [];
+		this._resetState();
+		if (r.timeout !== void 0) a.push(AbortSignal.timeout(r.timeout));
+		if (r.signal !== void 0) a.push(r.signal);
+		if (r.persist === true) i.detached = true;
+		if (a.length > 0) i.signal = P(a);
+		i.env = y(t, i.env, r.nodePath);
+		const o = D(this._command, this._args, i);
+		const s = spawn(o.command, o.args, o.options);
+		if (s.stderr) this._streamErr = s.stderr;
+		if (s.stdout) this._streamOut = s.stdout;
+		this._process = s;
+		s.once("error", this._onError);
+		s.once("close", this._onClose);
+		if (s.stdin) {
+			const { stdin: e } = r;
+			if (typeof e === "string") s.stdin.end(e);
+			else e?.process?.stdout?.pipe(s.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 = () => {
+		if (this._resolveClose) this._resolveClose();
+	};
+};
+const R = (e, t, n) => {
+	const r = new I(e, t, n);
+	r.spawn();
+	return r;
+};
+const z = R;
+//#endregion
+export { __commonJSMin as A, noop as C, resolveRegex as D, resolveComma as E, __toESM as M, slash as O, matchPattern as S, promiseWithResolvers as T, red as _, createDebug as a, debounce as b, generateColor as c, prettyFormat as d, blue as f, hex as g, green as h, version as i, __exportAll as j, toArray as k, getNameLabel as l, dim as m, z as n, LogLevels as o, bold as p, enableDebug as r, createLogger as s, R as t, globalLogger as u, underline as v, pkgExists as w, importWithError as x, yellow as y };