@nemo-cli/shared 0.0.1-beta.2

package/dist/index.js

@@ -0,0 +1,3078 @@
+import { createRequire } from "node:module";
+import path, { dirname as dirname$1, resolve } from "node:path";
+import fse from "fs-extra";
+import { glob as glob$1 } from "glob";
+import { cancel, confirm, group, groupMultiselect, intro, isCancel, log as log$1, multiselect, note, outro, progress, select, spinner, stream, taskLog, tasks, text } from "@clack/prompts";
+import ansiEscapes, { clearScreen as clearScreen$1, clearTerminal as clearTerminal$1 } from "ansi-escapes";
+import chalk, { default as colors } from "chalk";
+import winston from "winston";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "unconfig";
+import open, { apps, openApp } from "open";
+import process$1 from "node:process";
+import { Command } from "commander";
+import { x as x$1 } from "tinyexec";
+import { $ } from "zx";
+import { ErrorMessage } from "@nemo-cli/ui";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import Configstore from "configstore";
+import { search } from "@inquirer/prompts";
+import Fuse from "fuse.js";
+import instance, { spinners } from "ora";
+import fs from "node:fs/promises";
+import yaml from "yaml";
+
+//#region rolldown:runtime
+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), mod.exports);
+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));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/utils/types.ts
+const hasOwn = (target, key) => Object.hasOwn(target, key);
+const has = (target, key) => Reflect.has(target, key);
+const isType = (type) => (obj) => Object.prototype.toString.call(obj) === `[object ${type}]`;
+const isString = isType("String");
+const isNumber = isType("Number");
+const isBoolean = isType("Boolean");
+const isNull = isType("Null");
+const isUndefined = isType("Undefined");
+const isError = isType("Error");
+const isPromise = isType("Promise");
+const isPlainObject = isType("Object");
+const isArray = isType("Array");
+const isDate = isType("Date");
+const isFunction = isType("Function");
+const isSymbol = isType("Symbol");
+const isSet = isType("Set");
+const isMap = isType("Map");
+const isFormData = isType("FormData");
+const isURLSearchParams = isType("URLSearchParams");
+const isEmpty = (value) => {
+	if (value == null) return true;
+	if (isString(value)) return value.trim() === "";
+	if (isNumber(value)) return !Number.isFinite(value);
+	if (isArray(value)) return value.length === 0;
+	if (isPlainObject(value)) return Object.keys(value).length === 0;
+	return false;
+};
+
+//#endregion
+//#region src/utils/log.ts
+const customLevels = {
+	levels: {
+		error: 0,
+		warn: 1,
+		success: 2,
+		info: 3,
+		verbose: 4,
+		silly: 5,
+		timing: 6
+	},
+	colors: {
+		error: "red",
+		warn: "yellow",
+		success: "green",
+		info: "blue",
+		verbose: "cyan",
+		silly: "magenta",
+		timing: "grey"
+	}
+};
+const DEFAULT_OPTIONS = {
+	heading: "@nemo-cli",
+	level: "error"
+};
+winston.addColors(customLevels.colors);
+const init = (customOptions) => {
+	const options = {
+		...customOptions,
+		...DEFAULT_OPTIONS
+	};
+	return winston.createLogger({
+		level: options.level,
+		levels: customLevels.levels,
+		format: winston.format.combine(winston.format.colorize({ all: true })),
+		transports: [new winston.transports.Console({ format: winston.format.simple() })]
+	});
+};
+const logger = init();
+const transformMessage = (messages) => {
+	for (let i = 0; i < messages.length; i++) {
+		const [current, next] = [messages[i], messages[i + 1]];
+		if (isString(current) && isString(next)) messages.splice(i, 2, `${current}${next}`);
+	}
+	return messages;
+};
+const log = {
+	init,
+	get level() {
+		throw new Error("can't visit level");
+	},
+	set level(_) {
+		throw new Error("use setLevel");
+	},
+	setLevel(level) {
+		logger.level = level;
+	},
+	stopDebug() {
+		logger.level = "warn";
+		logger.warn("current winston level", logger.level);
+	},
+	show(message, options) {
+		const text$1 = options?.colors?.bold(message) ?? message;
+		const type = options?.type ?? "info";
+		if (options?.symbol) log$1.message(text$1, { symbol: options.symbol });
+		else log$1[type](text$1);
+	},
+	info(...messages) {
+		for (const message of transformMessage(messages)) if (isString(message)) logger.info(`${message}`);
+		else logger.info(`${JSON.stringify(message, null, 2)}`);
+	},
+	warn(...messages) {
+		for (const message of transformMessage(messages)) if (isString(message)) logger.warn(`${message}`);
+		else logger.warn(`${JSON.stringify(message, null, 2)}`);
+	},
+	debug() {
+		logger.warn("current winston level", logger.level);
+	},
+	timing(time) {
+		logger.log("timing", `${time}`);
+	},
+	error(...messages) {
+		for (const message of transformMessage(messages)) if (isString(message)) logger.error(`${chalk.red.bgBlack(message)}`);
+		else console.log(message);
+	},
+	verbose(...messages) {
+		for (const message of transformMessage(messages)) if (isString(message)) logger.verbose(`${message}`);
+		else logger.verbose(`${JSON.stringify(message, null, 2)}`);
+	},
+	success(...messages) {
+		for (const message of transformMessage(messages)) if (isString(message)) logger.log("success", `${chalk.green.bgBlack(message)}`);
+		else console.log(message);
+	},
+	clearScreen() {
+		process.stdout.write(ansiEscapes.clearScreen);
+	},
+	clearTerminal() {
+		process.stdout.write(ansiEscapes.clearTerminal);
+	},
+	beep() {
+		process.stdout.write(ansiEscapes.beep);
+	},
+	scrollDown() {
+		process.stdout.write(ansiEscapes.scrollDown);
+	},
+	scrollUp() {
+		process.stdout.write(ansiEscapes.scrollUp);
+	},
+	eraseEndLine() {
+		process.stdout.write(ansiEscapes.cursorPrevLine);
+		process.stdout.write(ansiEscapes.eraseLine);
+	}
+};
+
+//#endregion
+//#region src/utils/pathname.ts
+const filename = (importMate) => fileURLToPath(importMate.url);
+const dirname = (importMate) => dirname$1(filename(importMate));
+const cwdPathname = (dirname) => resolve(process.cwd(), dirname);
+const REGEXP_SPLIT_NAMES = /\W+/gm;
+const parseNames = (names) => names.split(REGEXP_SPLIT_NAMES);
+
+//#endregion
+//#region src/utils/file.ts
+const readPackage = (importMeta, ...paths) => {
+	try {
+		return readJSON(`${resolve(dirname(importMeta), ...paths)}/package.json`);
+	} catch (err) {
+		log.error("file readPackage error:", err.message);
+		process.exit(0);
+	}
+};
+const readJSON = (path$14, _overwrite = false) => {
+	if (fse.existsSync(path$14)) return fse.readJsonSync(path$14);
+	log.error("file", `你所查找的${path$14}文件不存在`);
+};
+const writeJSON = (path$14, content, force = false) => {
+	if (!fse.existsSync(path$14)) force ? fse.mkdirSync(dirname$1(path$14), { recursive: true }) : log.error("file", `你所查找的${path$14}文件不存在`);
+	return fse.writeFileSync(path$14, JSON.stringify(content, null, 2));
+};
+const readFile = (importMeta, ...paths) => {
+	const path$14 = resolve(dirname(importMeta), ...paths);
+	return fse.readFileSync(path$14, "utf-8");
+};
+const copyFile = (src, dest, _overwrite = false) => {
+	if (fse.existsSync(dest)) log.error("file", `${dest}`);
+	fse.copyFileSync(src, dest);
+};
+const checkFile = (src) => fse.existsSync(src);
+const deleteFile = (file) => fse.removeSync(file);
+const deleteFiles = (files) => {
+	for (const file of files) fse.removeSync(file);
+};
+const emptyDir = (src) => {
+	log.verbose("empty", src);
+	fse.emptyDirSync(src);
+};
+const emptyDirs = (dirs) => {
+	for (const dir of dirs) emptyDir(dir);
+};
+const isEmptyDir = (src) => {
+	return fse.readdirSync(src).length === 0;
+};
+const dirList = (src = "./") => {
+	return fileList(src).filter((file) => fse.statSync(`${src}/${file}`).isDirectory());
+};
+const fileList = (src = "./") => {
+	return fse.readdirSync(src);
+};
+const filterDirList = (list) => {
+	return list.filter((item) => fse.statSync(item).isDirectory());
+};
+function glob(pattern, options = {}) {
+	return glob$1(pattern, {
+		ignore: "node_modules/**",
+		...options
+	});
+}
+/**
+* 读取当前执行文件夹内的 .gitignore 文件内容
+* @param cwd 当前工作目录，默认为 process.cwd()
+* @returns .gitignore 文件内容，如果文件不存在则返回 null
+*/
+const readGitignore = (cwd = process.cwd()) => {
+	const gitignorePath = resolve(cwd, ".gitignore");
+	if (!fse.existsSync(gitignorePath)) {
+		log.verbose("gitignore", `未找到 .gitignore 文件: ${gitignorePath}`);
+		return [];
+	}
+	try {
+		const content = fse.readFileSync(gitignorePath, "utf-8");
+		log.verbose("gitignore", `成功读取 .gitignore 文件: ${gitignorePath}`);
+		return content.split("\n");
+	} catch (err) {
+		log.error("gitignore", `读取 .gitignore 文件失败: ${err.message}`);
+		return [];
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+const LOWEST_NODE_VERSION = "18.0.0";
+const CONFIG_NAME = ".nemoclirc";
+
+//#endregion
+//#region src/utils/browser.ts
+const openBrowser = (url) => {
+	open(url);
+};
+const openBrowserApp = (url) => {
+	openApp(url);
+};
+const getBrowserApps = () => {
+	return apps;
+};
+
+//#endregion
+//#region src/utils/color.ts
+const clearScreen = () => console.log(clearScreen$1);
+const clearTerminal = () => console.log(clearTerminal$1);
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject$1(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+	return key === "__proto__";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/object/merge.mjs
+function merge(target, source) {
+	const sourceKeys = Object.keys(source);
+	for (let i = 0; i < sourceKeys.length; i++) {
+		const key = sourceKeys[i];
+		if (isUnsafeProperty(key)) continue;
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
+		else if (Array.isArray(sourceValue)) target[key] = merge([], sourceValue);
+		else if (isPlainObject$1(sourceValue)) target[key] = merge({}, sourceValue);
+		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
+	}
+	return target;
+}
+function isMergeableValue(value) {
+	return isPlainObject$1(value) || Array.isArray(value);
+}
+
+//#endregion
+//#region src/utils/error.ts
+const handleError = (err, message) => {
+	if (isError(err)) ErrorMessage({ text: `${message}: ${err.message}` });
+	else if (isString(err)) ErrorMessage({ text: `${message}: ${err}` });
+	else log.error(message, err);
+};
+
+//#endregion
+//#region src/utils/command.ts
+const exit = (code) => process$1.exit(code);
+const createHelpExample = (...commands) => {
+	return `
+Example:
+${commands.map((command) => `  $ ${command}`).join("\n")}
+`;
+};
+const createCommand = (name) => {
+	const command = new Command(name);
+	command.allowExcessArguments();
+	command.allowUnknownOption();
+	return command;
+};
+const buildCommand = (command, dynamicParts = []) => {
+	return {
+		command,
+		parts: dynamicParts.filter((part) => !isEmpty(part)).map((part) => part?.toString())
+	};
+};
+const x = (command, args, options = {}) => {
+	return x$1(command, args, merge({
+		nodeOptions: {
+			cwd: process$1.cwd(),
+			FORCE_COLOR: "1"
+		},
+		throwOnError: true
+	}, options));
+};
+const zx = (baseCommand, dynamicParts = [], options = {}) => {
+	const { command, parts } = buildCommand(baseCommand, dynamicParts);
+	const { signal } = new AbortController();
+	try {
+		return (isEmpty(options) ? $ : $({
+			...options,
+			signal
+		}))`${command} ${parts}`;
+	} catch (error) {
+		handleError(error, `Failed to execute dynamic command: ${command}`);
+		throw error;
+	}
+};
+const checkCommand = async (_command) => {
+	try {
+		const a = await $`command -v git >/dev/null 2>&1`;
+		console.log("🚀 : checkCommand :  a:", a);
+		const b = await x$1("command", [
+			"-v",
+			"git",
+			">/dev/null",
+			"2>&1"
+		]);
+		console.log("🚀 : checkCommand :  b:", b);
+		const [error, result] = await xASync("command", [
+			"-v",
+			_command,
+			">/dev/null",
+			"2>&1"
+		]);
+		console.log("🚀 : checkCommand : result:", result);
+		if (error) return false;
+		return !!result.stdout;
+	} catch (error) {
+		console.log(error);
+		return false;
+	}
+};
+const xASync = async (command, args, options) => {
+	try {
+		const result = await x$1(command, args, options);
+		if (result.exitCode) {
+			!options?.quiet && log.show(`Failed to execute command ${command}. Command exited with code ${result.exitCode}.`, { type: "error" });
+			!options?.quiet && log.show(result.stderr, { type: "error" });
+			return [new Error(result.stderr), null];
+		}
+		return [null, result];
+	} catch (error) {
+		handleError(error, `Failed to execute command ${command}.`);
+		return [isError(error) ? error : new Error(error), null];
+	}
+};
+
+//#endregion
+//#region src/utils/common.ts
+const cached = (fn) => {
+	const map = /* @__PURE__ */ new Map();
+	return (content) => {
+		if (map.has(content)) return map.get(content);
+		const result = fn(content);
+		map.set(content, result);
+		return result;
+	};
+};
+const sleep = (millisecond, controller) => {
+	return new Promise((resolve$1, reject) => {
+		controller?.signal.addEventListener("abort", reject);
+		setTimeout(resolve$1, millisecond);
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "dotenv",
+		"version": "17.2.3",
+		"description": "Loads environment variables from .env file",
+		"main": "lib/main.js",
+		"types": "lib/main.d.ts",
+		"exports": {
+			".": {
+				"types": "./lib/main.d.ts",
+				"require": "./lib/main.js",
+				"default": "./lib/main.js"
+			},
+			"./config": "./config.js",
+			"./config.js": "./config.js",
+			"./lib/env-options": "./lib/env-options.js",
+			"./lib/env-options.js": "./lib/env-options.js",
+			"./lib/cli-options": "./lib/cli-options.js",
+			"./lib/cli-options.js": "./lib/cli-options.js",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"dts-check": "tsc --project tests/types/tsconfig.json",
+			"lint": "standard",
+			"pretest": "npm run lint && npm run dts-check",
+			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+			"prerelease": "npm test",
+			"release": "standard-version"
+		},
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/motdotla/dotenv.git"
+		},
+		"homepage": "https://github.com/motdotla/dotenv#readme",
+		"funding": "https://dotenvx.com",
+		"keywords": [
+			"dotenv",
+			"env",
+			".env",
+			"environment",
+			"variables",
+			"config",
+			"settings"
+		],
+		"readmeFilename": "README.md",
+		"license": "BSD-2-Clause",
+		"devDependencies": {
+			"@types/node": "^18.11.3",
+			"decache": "^4.6.2",
+			"sinon": "^14.0.1",
+			"standard": "^17.0.0",
+			"standard-version": "^9.5.0",
+			"tap": "^19.2.0",
+			"typescript": "^4.8.4"
+		},
+		"engines": { "node": ">=12" },
+		"browser": { "fs": false }
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$2 = __require("fs");
+	const path$13 = __require("path");
+	const os = __require("os");
+	const crypto = __require("crypto");
+	const version = require_package().version;
+	const TIPS = [
+		"🔐 encrypt with Dotenvx: https://dotenvx.com",
+		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
+		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
+		"📡 add observability to secrets: https://dotenvx.com/ops",
+		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
+		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
+		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
+		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
+		"🔑 add access controls to secrets: https://dotenvx.com/ops",
+		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
+		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+		"⚙️  enable debug logging with { debug: true }",
+		"⚙️  override existing env vars with { override: true }",
+		"⚙️  suppress all logs with { quiet: true }",
+		"⚙️  write to custom object with { processEnv: myObject }",
+		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text$1) {
+		return supportsAnsi() ? `\x1b[2m${text$1}\x1b[0m` : text$1;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options) {
+		options = options || {};
+		const vaultPath = _vaultPath(options);
+		options.path = vaultPath;
+		const result = DotenvModule.configDotenv(options);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+	function _debug(message) {
+		console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+	function _log(message) {
+		console.log(`[dotenv@${version}] ${message}`);
+	}
+	function _dotenvKey(options) {
+		if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) return options.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options) {
+		let possibleVaultPath = null;
+		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
+			for (const filepath of options.path) if (fs$2.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+		else possibleVaultPath = path$13.resolve(process.cwd(), ".env.vault");
+		if (fs$2.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path$13.join(os.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (debug || !quiet) _log("Loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options);
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		DotenvModule.populate(processEnv, parsed, options);
+		return { parsed };
+	}
+	function configDotenv(options) {
+		const dotenvPath = path$13.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (options && options.encoding) encoding = options.encoding;
+		else if (debug) _debug("No encoding is specified. UTF-8 is used by default");
+		let optionPaths = [dotenvPath];
+		if (options && options.path) if (!Array.isArray(options.path)) optionPaths = [_resolveHome(options.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path$14 of optionPaths) try {
+			const parsed = DotenvModule.parse(fs$2.readFileSync(path$14, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options);
+		} catch (e) {
+			if (debug) _debug(`Failed to load ${path$14} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path$13.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`Failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options) {
+		if (_dotenvKey(options).length === 0) return DotenvModule.configDotenv(options);
+		const vaultPath = _vaultPath(options);
+		if (!vaultPath) {
+			_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+			return DotenvModule.configDotenv(options);
+		}
+		return DotenvModule._configVault(options);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options = {}) {
+		const debug = Boolean(options && options.debug);
+		const override = Boolean(options && options.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+
+//#endregion
+//#region src/utils/config.ts
+var import_main = require_main();
+const configRootPath = path.resolve(homedir(), CONFIG_NAME);
+const loadEnv = (importMeta, ...paths) => {
+	const providedPath = path.resolve(dirname(importMeta), ...paths);
+	if (existsSync(providedPath)) {
+		(0, import_main.config)({
+			path: providedPath,
+			quiet: true
+		});
+		return;
+	}
+	throw new Error(`Environment file not found at ${providedPath}`);
+};
+const createStore = (name, options) => {
+	if (!options.path) throw Error("Store subpath is necessary!");
+	const configPath = path.resolve(configRootPath, options.path);
+	const store = new Configstore(name, options.default ?? {}, { configPath });
+	log.verbose("store created success", store.path);
+	return store;
+};
+
+//#endregion
+//#region src/utils/env.ts
+const isDebug = () => process.argv.includes("-d") || process.argv.includes("--debug");
+
+//#endregion
+//#region src/utils/format.ts
+const CHINESE_STRING_REGEXP = /[\u4e00-\u9fa5]/;
+const isChinese = (text$1) => CHINESE_STRING_REGEXP.test(text$1);
+
+//#endregion
+//#region src/utils/git-handle/index.ts
+const require$1 = createRequire(import.meta.url);
+const currentBranchPrefix = /^\* /;
+const formatBranch = (branch) => branch?.trim().replace(currentBranchPrefix, "");
+const getCurrentBranch = async () => {
+	const [error, result] = await xASync("git", ["branch", "--show-current"]);
+	if (error) return "";
+	return result.stdout.trim();
+};
+const getLocalBranches = async () => {
+	const list = (await x("git", ["branch"])).stdout.split("\n");
+	const currentBranch = list.find((line) => line.includes("*"));
+	return {
+		branches: list.filter((line) => line.trim() && !line.includes("->")).map((line) => line.trim().replace(currentBranchPrefix, "")),
+		currentBranch: formatBranch(currentBranch)
+	};
+};
+const getDiffFiles = async () => {
+	return (await x("git", [
+		"diff",
+		"HEAD",
+		"origin/main",
+		"--name-only"
+	])).stdout.split("\n").filter((line) => line.trim() !== "");
+};
+const getGitStatus = async () => {
+	const lines = (await x("git", ["status", "--porcelain"])).stdout.split("\n").filter((line) => line.trim() !== "");
+	const staged = [];
+	const modified = [];
+	const untracked = [];
+	for (const line of lines) {
+		const indexStatus = line[0];
+		const workingStatus = line[1];
+		const fileName = line.slice(3);
+		if (indexStatus !== " " && indexStatus !== "?") staged.push(fileName);
+		if (workingStatus === "M" || workingStatus === "D") modified.push(fileName);
+		if (indexStatus === "?" && workingStatus === "?") untracked.push(fileName);
+	}
+	return {
+		staged,
+		modified,
+		untracked,
+		unstaged: [...modified, ...untracked]
+	};
+};
+const addFiles = async (files) => {
+	if (files.length === 0) return;
+	return await x("git", ["add", ...files]);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js
+var require_universalify = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.fromCallback = function(fn) {
+		return Object.defineProperty(function(...args) {
+			if (typeof args[args.length - 1] === "function") fn.apply(this, args);
+			else return new Promise((resolve$1, reject) => {
+				args.push((err, res) => err != null ? reject(err) : resolve$1(res));
+				fn.apply(this, args);
+			});
+		}, "name", { value: fn.name });
+	};
+	exports.fromPromise = function(fn) {
+		return Object.defineProperty(function(...args) {
+			const cb = args[args.length - 1];
+			if (typeof cb !== "function") return fn.apply(this, args);
+			else {
+				args.pop();
+				fn.apply(this, args).then((r) => cb(null, r), cb);
+			}
+		}, "name", { value: fn.name });
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants = __require("constants");
+	var origCwd = process.cwd;
+	var cwd = null;
+	var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+	process.cwd = function() {
+		if (!cwd) cwd = origCwd.call(process);
+		return cwd;
+	};
+	try {
+		process.cwd();
+	} catch (er) {}
+	if (typeof process.chdir === "function") {
+		var chdir = process.chdir;
+		process.chdir = function(d) {
+			cwd = null;
+			chdir.call(process, d);
+		};
+		if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+	}
+	module.exports = patch;
+	function patch(fs$3) {
+		if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs$3);
+		if (!fs$3.lutimes) patchLutimes(fs$3);
+		fs$3.chown = chownFix(fs$3.chown);
+		fs$3.fchown = chownFix(fs$3.fchown);
+		fs$3.lchown = chownFix(fs$3.lchown);
+		fs$3.chmod = chmodFix(fs$3.chmod);
+		fs$3.fchmod = chmodFix(fs$3.fchmod);
+		fs$3.lchmod = chmodFix(fs$3.lchmod);
+		fs$3.chownSync = chownFixSync(fs$3.chownSync);
+		fs$3.fchownSync = chownFixSync(fs$3.fchownSync);
+		fs$3.lchownSync = chownFixSync(fs$3.lchownSync);
+		fs$3.chmodSync = chmodFixSync(fs$3.chmodSync);
+		fs$3.fchmodSync = chmodFixSync(fs$3.fchmodSync);
+		fs$3.lchmodSync = chmodFixSync(fs$3.lchmodSync);
+		fs$3.stat = statFix(fs$3.stat);
+		fs$3.fstat = statFix(fs$3.fstat);
+		fs$3.lstat = statFix(fs$3.lstat);
+		fs$3.statSync = statFixSync(fs$3.statSync);
+		fs$3.fstatSync = statFixSync(fs$3.fstatSync);
+		fs$3.lstatSync = statFixSync(fs$3.lstatSync);
+		if (fs$3.chmod && !fs$3.lchmod) {
+			fs$3.lchmod = function(path$14, mode, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs$3.lchmodSync = function() {};
+		}
+		if (fs$3.chown && !fs$3.lchown) {
+			fs$3.lchown = function(path$14, uid, gid, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs$3.lchownSync = function() {};
+		}
+		if (platform === "win32") fs$3.rename = typeof fs$3.rename !== "function" ? fs$3.rename : (function(fs$rename) {
+			function rename(from, to, cb) {
+				var start = Date.now();
+				var backoff = 0;
+				fs$rename(from, to, function CB(er) {
+					if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+						setTimeout(function() {
+							fs$3.stat(to, function(stater, st) {
+								if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);
+								else cb(er);
+							});
+						}, backoff);
+						if (backoff < 100) backoff += 10;
+						return;
+					}
+					if (cb) cb(er);
+				});
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+			return rename;
+		})(fs$3.rename);
+		fs$3.read = typeof fs$3.read !== "function" ? fs$3.read : (function(fs$read) {
+			function read(fd, buffer, offset, length, position, callback_) {
+				var callback;
+				if (callback_ && typeof callback_ === "function") {
+					var eagCounter = 0;
+					callback = function(er, _, __) {
+						if (er && er.code === "EAGAIN" && eagCounter < 10) {
+							eagCounter++;
+							return fs$read.call(fs$3, fd, buffer, offset, length, position, callback);
+						}
+						callback_.apply(this, arguments);
+					};
+				}
+				return fs$read.call(fs$3, fd, buffer, offset, length, position, callback);
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+			return read;
+		})(fs$3.read);
+		fs$3.readSync = typeof fs$3.readSync !== "function" ? fs$3.readSync : (function(fs$readSync) {
+			return function(fd, buffer, offset, length, position) {
+				var eagCounter = 0;
+				while (true) try {
+					return fs$readSync.call(fs$3, fd, buffer, offset, length, position);
+				} catch (er) {
+					if (er.code === "EAGAIN" && eagCounter < 10) {
+						eagCounter++;
+						continue;
+					}
+					throw er;
+				}
+			};
+		})(fs$3.readSync);
+		function patchLchmod(fs$4) {
+			fs$4.lchmod = function(path$14, mode, callback) {
+				fs$4.open(path$14, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+					if (err) {
+						if (callback) callback(err);
+						return;
+					}
+					fs$4.fchmod(fd, mode, function(err$1) {
+						fs$4.close(fd, function(err2) {
+							if (callback) callback(err$1 || err2);
+						});
+					});
+				});
+			};
+			fs$4.lchmodSync = function(path$14, mode) {
+				var fd = fs$4.openSync(path$14, constants.O_WRONLY | constants.O_SYMLINK, mode);
+				var threw = true;
+				var ret;
+				try {
+					ret = fs$4.fchmodSync(fd, mode);
+					threw = false;
+				} finally {
+					if (threw) try {
+						fs$4.closeSync(fd);
+					} catch (er) {}
+					else fs$4.closeSync(fd);
+				}
+				return ret;
+			};
+		}
+		function patchLutimes(fs$4) {
+			if (constants.hasOwnProperty("O_SYMLINK") && fs$4.futimes) {
+				fs$4.lutimes = function(path$14, at, mt, cb) {
+					fs$4.open(path$14, constants.O_SYMLINK, function(er, fd) {
+						if (er) {
+							if (cb) cb(er);
+							return;
+						}
+						fs$4.futimes(fd, at, mt, function(er$1) {
+							fs$4.close(fd, function(er2) {
+								if (cb) cb(er$1 || er2);
+							});
+						});
+					});
+				};
+				fs$4.lutimesSync = function(path$14, at, mt) {
+					var fd = fs$4.openSync(path$14, constants.O_SYMLINK);
+					var ret;
+					var threw = true;
+					try {
+						ret = fs$4.futimesSync(fd, at, mt);
+						threw = false;
+					} finally {
+						if (threw) try {
+							fs$4.closeSync(fd);
+						} catch (er) {}
+						else fs$4.closeSync(fd);
+					}
+					return ret;
+				};
+			} else if (fs$4.futimes) {
+				fs$4.lutimes = function(_a, _b, _c, cb) {
+					if (cb) process.nextTick(cb);
+				};
+				fs$4.lutimesSync = function() {};
+			}
+		}
+		function chmodFix(orig) {
+			if (!orig) return orig;
+			return function(target, mode, cb) {
+				return orig.call(fs$3, target, mode, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chmodFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, mode) {
+				try {
+					return orig.call(fs$3, target, mode);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function chownFix(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid, cb) {
+				return orig.call(fs$3, target, uid, gid, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chownFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid) {
+				try {
+					return orig.call(fs$3, target, uid, gid);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function statFix(orig) {
+			if (!orig) return orig;
+			return function(target, options, cb) {
+				if (typeof options === "function") {
+					cb = options;
+					options = null;
+				}
+				function callback(er, stats) {
+					if (stats) {
+						if (stats.uid < 0) stats.uid += 4294967296;
+						if (stats.gid < 0) stats.gid += 4294967296;
+					}
+					if (cb) cb.apply(this, arguments);
+				}
+				return options ? orig.call(fs$3, target, options, callback) : orig.call(fs$3, target, callback);
+			};
+		}
+		function statFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, options) {
+				var stats = options ? orig.call(fs$3, target, options) : orig.call(fs$3, target);
+				if (stats) {
+					if (stats.uid < 0) stats.uid += 4294967296;
+					if (stats.gid < 0) stats.gid += 4294967296;
+				}
+				return stats;
+			};
+		}
+		function chownErOk(er) {
+			if (!er) return true;
+			if (er.code === "ENOSYS") return true;
+			if (!process.getuid || process.getuid() !== 0) {
+				if (er.code === "EINVAL" || er.code === "EPERM") return true;
+			}
+			return false;
+		}
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream = __require("stream").Stream;
+	module.exports = legacy;
+	function legacy(fs$3) {
+		return {
+			ReadStream,
+			WriteStream
+		};
+		function ReadStream(path$14, options) {
+			if (!(this instanceof ReadStream)) return new ReadStream(path$14, options);
+			Stream.call(this);
+			var self = this;
+			this.path = path$14;
+			this.fd = null;
+			this.readable = true;
+			this.paused = false;
+			this.flags = "r";
+			this.mode = 438;
+			this.bufferSize = 64 * 1024;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.encoding) this.setEncoding(this.encoding);
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.end === void 0) this.end = Infinity;
+				else if ("number" !== typeof this.end) throw TypeError("end must be a Number");
+				if (this.start > this.end) throw new Error("start must be <= end");
+				this.pos = this.start;
+			}
+			if (this.fd !== null) {
+				process.nextTick(function() {
+					self._read();
+				});
+				return;
+			}
+			fs$3.open(this.path, this.flags, this.mode, function(err, fd) {
+				if (err) {
+					self.emit("error", err);
+					self.readable = false;
+					return;
+				}
+				self.fd = fd;
+				self.emit("open", fd);
+				self._read();
+			});
+		}
+		function WriteStream(path$14, options) {
+			if (!(this instanceof WriteStream)) return new WriteStream(path$14, options);
+			Stream.call(this);
+			this.path = path$14;
+			this.fd = null;
+			this.writable = true;
+			this.flags = "w";
+			this.encoding = "binary";
+			this.mode = 438;
+			this.bytesWritten = 0;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.start < 0) throw new Error("start must be >= zero");
+				this.pos = this.start;
+			}
+			this.busy = false;
+			this._queue = [];
+			if (this.fd === null) {
+				this._open = fs$3.open;
+				this._queue.push([
+					this._open,
+					this.path,
+					this.flags,
+					this.mode,
+					void 0
+				]);
+				this.flush();
+			}
+		}
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = clone;
+	var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+		return obj.__proto__;
+	};
+	function clone(obj) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (obj instanceof Object) var copy$1 = { __proto__: getPrototypeOf(obj) };
+		else var copy$1 = Object.create(null);
+		Object.getOwnPropertyNames(obj).forEach(function(key) {
+			Object.defineProperty(copy$1, key, Object.getOwnPropertyDescriptor(obj, key));
+		});
+		return copy$1;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs$1 = __require("fs");
+	var polyfills = require_polyfills();
+	var legacy = require_legacy_streams();
+	var clone = require_clone();
+	var util = __require("util");
+	/* istanbul ignore next - node 0.x polyfill */
+	var gracefulQueue;
+	var previousSymbol;
+	/* istanbul ignore else - node 0.x polyfill */
+	if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+		gracefulQueue = Symbol.for("graceful-fs.queue");
+		previousSymbol = Symbol.for("graceful-fs.previous");
+	} else {
+		gracefulQueue = "___graceful-fs.queue";
+		previousSymbol = "___graceful-fs.previous";
+	}
+	function noop() {}
+	function publishQueue(context, queue) {
+		Object.defineProperty(context, gracefulQueue, { get: function() {
+			return queue;
+		} });
+	}
+	var debug = noop;
+	if (util.debuglog) debug = util.debuglog("gfs4");
+	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) debug = function() {
+		var m = util.format.apply(util, arguments);
+		m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+		console.error(m);
+	};
+	if (!fs$1[gracefulQueue]) {
+		publishQueue(fs$1, global[gracefulQueue] || []);
+		fs$1.close = (function(fs$close) {
+			function close(fd, cb) {
+				return fs$close.call(fs$1, fd, function(err) {
+					if (!err) resetQueue();
+					if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+			Object.defineProperty(close, previousSymbol, { value: fs$close });
+			return close;
+		})(fs$1.close);
+		fs$1.closeSync = (function(fs$closeSync) {
+			function closeSync(fd) {
+				fs$closeSync.apply(fs$1, arguments);
+				resetQueue();
+			}
+			Object.defineProperty(closeSync, previousSymbol, { value: fs$closeSync });
+			return closeSync;
+		})(fs$1.closeSync);
+		if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
+			debug(fs$1[gracefulQueue]);
+			__require("assert").equal(fs$1[gracefulQueue].length, 0);
+		});
+	}
+	if (!global[gracefulQueue]) publishQueue(global, fs$1[gracefulQueue]);
+	module.exports = patch(clone(fs$1));
+	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$1.__patched) {
+		module.exports = patch(fs$1);
+		fs$1.__patched = true;
+	}
+	function patch(fs$3) {
+		polyfills(fs$3);
+		fs$3.gracefulify = patch;
+		fs$3.createReadStream = createReadStream;
+		fs$3.createWriteStream = createWriteStream;
+		var fs$readFile = fs$3.readFile;
+		fs$3.readFile = readFile$1;
+		function readFile$1(path$14, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$readFile(path$14, options, cb);
+			function go$readFile(path$15, options$1, cb$1, startTime) {
+				return fs$readFile(path$15, options$1, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readFile,
+						[
+							path$15,
+							options$1,
+							cb$1
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+				});
+			}
+		}
+		var fs$writeFile = fs$3.writeFile;
+		fs$3.writeFile = writeFile;
+		function writeFile(path$14, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$writeFile(path$14, data, options, cb);
+			function go$writeFile(path$15, data$1, options$1, cb$1, startTime) {
+				return fs$writeFile(path$15, data$1, options$1, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$writeFile,
+						[
+							path$15,
+							data$1,
+							options$1,
+							cb$1
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+				});
+			}
+		}
+		var fs$appendFile = fs$3.appendFile;
+		if (fs$appendFile) fs$3.appendFile = appendFile;
+		function appendFile(path$14, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$appendFile(path$14, data, options, cb);
+			function go$appendFile(path$15, data$1, options$1, cb$1, startTime) {
+				return fs$appendFile(path$15, data$1, options$1, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$appendFile,
+						[
+							path$15,
+							data$1,
+							options$1,
+							cb$1
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+				});
+			}
+		}
+		var fs$copyFile = fs$3.copyFile;
+		if (fs$copyFile) fs$3.copyFile = copyFile$1;
+		function copyFile$1(src, dest, flags, cb) {
+			if (typeof flags === "function") {
+				cb = flags;
+				flags = 0;
+			}
+			return go$copyFile(src, dest, flags, cb);
+			function go$copyFile(src$1, dest$1, flags$1, cb$1, startTime) {
+				return fs$copyFile(src$1, dest$1, flags$1, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$copyFile,
+						[
+							src$1,
+							dest$1,
+							flags$1,
+							cb$1
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+				});
+			}
+		}
+		var fs$readdir = fs$3.readdir;
+		fs$3.readdir = readdir;
+		var noReaddirOptionVersions = /^v[0-5]\./;
+		function readdir(path$14, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir$1(path$15, options$1, cb$1, startTime) {
+				return fs$readdir(path$15, fs$readdirCallback(path$15, options$1, cb$1, startTime));
+			} : function go$readdir$1(path$15, options$1, cb$1, startTime) {
+				return fs$readdir(path$15, options$1, fs$readdirCallback(path$15, options$1, cb$1, startTime));
+			};
+			return go$readdir(path$14, options, cb);
+			function fs$readdirCallback(path$15, options$1, cb$1, startTime) {
+				return function(err, files) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readdir,
+						[
+							path$15,
+							options$1,
+							cb$1
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else {
+						if (files && files.sort) files.sort();
+						if (typeof cb$1 === "function") cb$1.call(this, err, files);
+					}
+				};
+			}
+		}
+		if (process.version.substr(0, 4) === "v0.8") {
+			var legStreams = legacy(fs$3);
+			ReadStream = legStreams.ReadStream;
+			WriteStream = legStreams.WriteStream;
+		}
+		var fs$ReadStream = fs$3.ReadStream;
+		if (fs$ReadStream) {
+			ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+			ReadStream.prototype.open = ReadStream$open;
+		}
+		var fs$WriteStream = fs$3.WriteStream;
+		if (fs$WriteStream) {
+			WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+			WriteStream.prototype.open = WriteStream$open;
+		}
+		Object.defineProperty(fs$3, "ReadStream", {
+			get: function() {
+				return ReadStream;
+			},
+			set: function(val) {
+				ReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		Object.defineProperty(fs$3, "WriteStream", {
+			get: function() {
+				return WriteStream;
+			},
+			set: function(val) {
+				WriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileReadStream = ReadStream;
+		Object.defineProperty(fs$3, "FileReadStream", {
+			get: function() {
+				return FileReadStream;
+			},
+			set: function(val) {
+				FileReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileWriteStream = WriteStream;
+		Object.defineProperty(fs$3, "FileWriteStream", {
+			get: function() {
+				return FileWriteStream;
+			},
+			set: function(val) {
+				FileWriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		function ReadStream(path$14, options) {
+			if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;
+			else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+		}
+		function ReadStream$open() {
+			var that = this;
+			open$1(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					if (that.autoClose) that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+					that.read();
+				}
+			});
+		}
+		function WriteStream(path$14, options) {
+			if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;
+			else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+		}
+		function WriteStream$open() {
+			var that = this;
+			open$1(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+				}
+			});
+		}
+		function createReadStream(path$14, options) {
+			return new fs$3.ReadStream(path$14, options);
+		}
+		function createWriteStream(path$14, options) {
+			return new fs$3.WriteStream(path$14, options);
+		}
+		var fs$open = fs$3.open;
+		fs$3.open = open$1;
+		function open$1(path$14, flags, mode, cb) {
+			if (typeof mode === "function") cb = mode, mode = null;
+			return go$open(path$14, flags, mode, cb);
+			function go$open(path$15, flags$1, mode$1, cb$1, startTime) {
+				return fs$open(path$15, flags$1, mode$1, function(err, fd) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$open,
+						[
+							path$15,
+							flags$1,
+							mode$1,
+							cb$1
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb$1 === "function") cb$1.apply(this, arguments);
+				});
+			}
+		}
+		return fs$3;
+	}
+	function enqueue(elem) {
+		debug("ENQUEUE", elem[0].name, elem[1]);
+		fs$1[gracefulQueue].push(elem);
+		retry();
+	}
+	var retryTimer;
+	function resetQueue() {
+		var now = Date.now();
+		for (var i = 0; i < fs$1[gracefulQueue].length; ++i) if (fs$1[gracefulQueue][i].length > 2) {
+			fs$1[gracefulQueue][i][3] = now;
+			fs$1[gracefulQueue][i][4] = now;
+		}
+		retry();
+	}
+	function retry() {
+		clearTimeout(retryTimer);
+		retryTimer = void 0;
+		if (fs$1[gracefulQueue].length === 0) return;
+		var elem = fs$1[gracefulQueue].shift();
+		var fn = elem[0];
+		var args = elem[1];
+		var err = elem[2];
+		var startTime = elem[3];
+		var lastTime = elem[4];
+		if (startTime === void 0) {
+			debug("RETRY", fn.name, args);
+			fn.apply(null, args);
+		} else if (Date.now() - startTime >= 6e4) {
+			debug("TIMEOUT", fn.name, args);
+			var cb = args.pop();
+			if (typeof cb === "function") cb.call(null, err);
+		} else {
+			var sinceAttempt = Date.now() - lastTime;
+			var sinceStart = Math.max(lastTime - startTime, 1);
+			if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
+				debug("RETRY", fn.name, args);
+				fn.apply(null, args.concat([startTime]));
+			} else fs$1[gracefulQueue].push(elem);
+		}
+		if (retryTimer === void 0) retryTimer = setTimeout(retry, 0);
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/fs/index.js
+var require_fs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const u = require_universalify().fromCallback;
+	const fs = require_graceful_fs();
+	const api = [
+		"access",
+		"appendFile",
+		"chmod",
+		"chown",
+		"close",
+		"copyFile",
+		"cp",
+		"fchmod",
+		"fchown",
+		"fdatasync",
+		"fstat",
+		"fsync",
+		"ftruncate",
+		"futimes",
+		"glob",
+		"lchmod",
+		"lchown",
+		"lutimes",
+		"link",
+		"lstat",
+		"mkdir",
+		"mkdtemp",
+		"open",
+		"opendir",
+		"readdir",
+		"readFile",
+		"readlink",
+		"realpath",
+		"rename",
+		"rm",
+		"rmdir",
+		"stat",
+		"statfs",
+		"symlink",
+		"truncate",
+		"unlink",
+		"utimes",
+		"writeFile"
+	].filter((key) => {
+		return typeof fs[key] === "function";
+	});
+	Object.assign(exports, fs);
+	api.forEach((method) => {
+		exports[method] = u(fs[method]);
+	});
+	exports.exists = function(filename$1, callback) {
+		if (typeof callback === "function") return fs.exists(filename$1, callback);
+		return new Promise((resolve$1) => {
+			return fs.exists(filename$1, resolve$1);
+		});
+	};
+	exports.read = function(fd, buffer, offset, length, position, callback) {
+		if (typeof callback === "function") return fs.read(fd, buffer, offset, length, position, callback);
+		return new Promise((resolve$1, reject) => {
+			fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer$1) => {
+				if (err) return reject(err);
+				resolve$1({
+					bytesRead,
+					buffer: buffer$1
+				});
+			});
+		});
+	};
+	exports.write = function(fd, buffer, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.write(fd, buffer, ...args);
+		return new Promise((resolve$1, reject) => {
+			fs.write(fd, buffer, ...args, (err, bytesWritten, buffer$1) => {
+				if (err) return reject(err);
+				resolve$1({
+					bytesWritten,
+					buffer: buffer$1
+				});
+			});
+		});
+	};
+	exports.readv = function(fd, buffers, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.readv(fd, buffers, ...args);
+		return new Promise((resolve$1, reject) => {
+			fs.readv(fd, buffers, ...args, (err, bytesRead, buffers$1) => {
+				if (err) return reject(err);
+				resolve$1({
+					bytesRead,
+					buffers: buffers$1
+				});
+			});
+		});
+	};
+	exports.writev = function(fd, buffers, ...args) {
+		if (typeof args[args.length - 1] === "function") return fs.writev(fd, buffers, ...args);
+		return new Promise((resolve$1, reject) => {
+			fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers$1) => {
+				if (err) return reject(err);
+				resolve$1({
+					bytesWritten,
+					buffers: buffers$1
+				});
+			});
+		});
+	};
+	if (typeof fs.realpath.native === "function") exports.realpath.native = u(fs.realpath.native);
+	else process.emitWarning("fs.realpath.native is not a function. Is fs being monkey-patched?", "Warning", "fs-extra-WARN0003");
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$12 = __require("path");
+	module.exports.checkPath = function checkPath(pth) {
+		if (process.platform === "win32") {
+			if (/[<>:"|?*]/.test(pth.replace(path$12.parse(pth).root, ""))) {
+				const error = /* @__PURE__ */ new Error(`Path contains invalid characters: ${pth}`);
+				error.code = "EINVAL";
+				throw error;
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const { checkPath } = require_utils$1();
+	const getMode = (options) => {
+		const defaults = { mode: 511 };
+		if (typeof options === "number") return options;
+		return {
+			...defaults,
+			...options
+		}.mode;
+	};
+	module.exports.makeDir = async (dir, options) => {
+		checkPath(dir);
+		return fs.mkdir(dir, {
+			mode: getMode(options),
+			recursive: true
+		});
+	};
+	module.exports.makeDirSync = (dir, options) => {
+		checkPath(dir);
+		return fs.mkdirSync(dir, {
+			mode: getMode(options),
+			recursive: true
+		});
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const { makeDir: _makeDir, makeDirSync } = require_make_dir();
+	const makeDir = u(_makeDir);
+	module.exports = {
+		mkdirs: makeDir,
+		mkdirsSync: makeDirSync,
+		mkdirp: makeDir,
+		mkdirpSync: makeDirSync,
+		ensureDir: makeDir,
+		ensureDirSync: makeDirSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	function pathExists(path$14) {
+		return fs.access(path$14).then(() => true).catch(() => false);
+	}
+	module.exports = {
+		pathExists: u(pathExists),
+		pathExistsSync: fs.existsSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const u = require_universalify().fromPromise;
+	async function utimesMillis(path$14, atime, mtime) {
+		const fd = await fs.open(path$14, "r+");
+		let closeErr = null;
+		try {
+			await fs.futimes(fd, atime, mtime);
+		} finally {
+			try {
+				await fs.close(fd);
+			} catch (e) {
+				closeErr = e;
+			}
+		}
+		if (closeErr) throw closeErr;
+	}
+	function utimesMillisSync(path$14, atime, mtime) {
+		const fd = fs.openSync(path$14, "r+");
+		fs.futimesSync(fd, atime, mtime);
+		return fs.closeSync(fd);
+	}
+	module.exports = {
+		utimesMillis: u(utimesMillis),
+		utimesMillisSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/util/stat.js
+var require_stat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path$11 = __require("path");
+	const u = require_universalify().fromPromise;
+	function getStats(src, dest, opts) {
+		const statFunc = opts.dereference ? (file) => fs.stat(file, { bigint: true }) : (file) => fs.lstat(file, { bigint: true });
+		return Promise.all([statFunc(src), statFunc(dest).catch((err) => {
+			if (err.code === "ENOENT") return null;
+			throw err;
+		})]).then(([srcStat, destStat]) => ({
+			srcStat,
+			destStat
+		}));
+	}
+	function getStatsSync(src, dest, opts) {
+		let destStat;
+		const statFunc = opts.dereference ? (file) => fs.statSync(file, { bigint: true }) : (file) => fs.lstatSync(file, { bigint: true });
+		const srcStat = statFunc(src);
+		try {
+			destStat = statFunc(dest);
+		} catch (err) {
+			if (err.code === "ENOENT") return {
+				srcStat,
+				destStat: null
+			};
+			throw err;
+		}
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	async function checkPaths(src, dest, funcName, opts) {
+		const { srcStat, destStat } = await getStats(src, dest, opts);
+		if (destStat) {
+			if (areIdentical(srcStat, destStat)) {
+				const srcBaseName = path$11.basename(src);
+				const destBaseName = path$11.basename(dest);
+				if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
+					srcStat,
+					destStat,
+					isChangingCase: true
+				};
+				throw new Error("Source and destination must not be the same.");
+			}
+			if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+			if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+		}
+		if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	function checkPathsSync(src, dest, funcName, opts) {
+		const { srcStat, destStat } = getStatsSync(src, dest, opts);
+		if (destStat) {
+			if (areIdentical(srcStat, destStat)) {
+				const srcBaseName = path$11.basename(src);
+				const destBaseName = path$11.basename(dest);
+				if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) return {
+					srcStat,
+					destStat,
+					isChangingCase: true
+				};
+				throw new Error("Source and destination must not be the same.");
+			}
+			if (srcStat.isDirectory() && !destStat.isDirectory()) throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+			if (!srcStat.isDirectory() && destStat.isDirectory()) throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+		}
+		if (srcStat.isDirectory() && isSrcSubdir(src, dest)) throw new Error(errMsg(src, dest, funcName));
+		return {
+			srcStat,
+			destStat
+		};
+	}
+	async function checkParentPaths(src, srcStat, dest, funcName) {
+		const srcParent = path$11.resolve(path$11.dirname(src));
+		const destParent = path$11.resolve(path$11.dirname(dest));
+		if (destParent === srcParent || destParent === path$11.parse(destParent).root) return;
+		let destStat;
+		try {
+			destStat = await fs.stat(destParent, { bigint: true });
+		} catch (err) {
+			if (err.code === "ENOENT") return;
+			throw err;
+		}
+		if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
+		return checkParentPaths(src, srcStat, destParent, funcName);
+	}
+	function checkParentPathsSync(src, srcStat, dest, funcName) {
+		const srcParent = path$11.resolve(path$11.dirname(src));
+		const destParent = path$11.resolve(path$11.dirname(dest));
+		if (destParent === srcParent || destParent === path$11.parse(destParent).root) return;
+		let destStat;
+		try {
+			destStat = fs.statSync(destParent, { bigint: true });
+		} catch (err) {
+			if (err.code === "ENOENT") return;
+			throw err;
+		}
+		if (areIdentical(srcStat, destStat)) throw new Error(errMsg(src, dest, funcName));
+		return checkParentPathsSync(src, srcStat, destParent, funcName);
+	}
+	function areIdentical(srcStat, destStat) {
+		return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+	}
+	function isSrcSubdir(src, dest) {
+		const srcArr = path$11.resolve(src).split(path$11.sep).filter((i) => i);
+		const destArr = path$11.resolve(dest).split(path$11.sep).filter((i) => i);
+		return srcArr.every((cur, i) => destArr[i] === cur);
+	}
+	function errMsg(src, dest, funcName) {
+		return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+	}
+	module.exports = {
+		checkPaths: u(checkPaths),
+		checkPathsSync,
+		checkParentPaths: u(checkParentPaths),
+		checkParentPathsSync,
+		isSrcSubdir,
+		areIdentical
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/util/async.js
+var require_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	async function asyncIteratorConcurrentProcess(iterator, fn) {
+		const promises = [];
+		for await (const item of iterator) promises.push(fn(item).then(() => null, (err) => err ?? /* @__PURE__ */ new Error("unknown error")));
+		await Promise.all(promises.map((promise) => promise.then((possibleErr) => {
+			if (possibleErr !== null) throw possibleErr;
+		})));
+	}
+	module.exports = { asyncIteratorConcurrentProcess };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/copy/copy.js
+var require_copy$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path$10 = __require("path");
+	const { mkdirs } = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const { utimesMillis } = require_utimes();
+	const stat = require_stat();
+	const { asyncIteratorConcurrentProcess } = require_async();
+	async function copy(src, dest, opts = {}) {
+		if (typeof opts === "function") opts = { filter: opts };
+		opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+		opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+		if (opts.preserveTimestamps && process.arch === "ia32") process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0001");
+		const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts);
+		await stat.checkParentPaths(src, srcStat, dest, "copy");
+		if (!await runFilter(src, dest, opts)) return;
+		const destParent = path$10.dirname(dest);
+		if (!await pathExists(destParent)) await mkdirs(destParent);
+		await getStatsAndPerformCopy(destStat, src, dest, opts);
+	}
+	async function runFilter(src, dest, opts) {
+		if (!opts.filter) return true;
+		return opts.filter(src, dest);
+	}
+	async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+		const srcStat = await (opts.dereference ? fs.stat : fs.lstat)(src);
+		if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+		if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+		if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+		if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+		if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+		throw new Error(`Unknown file: ${src}`);
+	}
+	async function onFile(srcStat, destStat, src, dest, opts) {
+		if (!destStat) return copyFile(srcStat, src, dest, opts);
+		if (opts.overwrite) {
+			await fs.unlink(dest);
+			return copyFile(srcStat, src, dest, opts);
+		}
+		if (opts.errorOnExist) throw new Error(`'${dest}' already exists`);
+	}
+	async function copyFile(srcStat, src, dest, opts) {
+		await fs.copyFile(src, dest);
+		if (opts.preserveTimestamps) {
+			if (fileIsNotWritable(srcStat.mode)) await makeFileWritable(dest, srcStat.mode);
+			const updatedSrcStat = await fs.stat(src);
+			await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+		}
+		return fs.chmod(dest, srcStat.mode);
+	}
+	function fileIsNotWritable(srcMode) {
+		return (srcMode & 128) === 0;
+	}
+	function makeFileWritable(dest, srcMode) {
+		return fs.chmod(dest, srcMode | 128);
+	}
+	async function onDir(srcStat, destStat, src, dest, opts) {
+		if (!destStat) await fs.mkdir(dest);
+		await asyncIteratorConcurrentProcess(await fs.opendir(src), async (item) => {
+			const srcItem = path$10.join(src, item.name);
+			const destItem = path$10.join(dest, item.name);
+			if (await runFilter(srcItem, destItem, opts)) {
+				const { destStat: destStat$1 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
+				await getStatsAndPerformCopy(destStat$1, srcItem, destItem, opts);
+			}
+		});
+		if (!destStat) await fs.chmod(dest, srcStat.mode);
+	}
+	async function onLink(destStat, src, dest, opts) {
+		let resolvedSrc = await fs.readlink(src);
+		if (opts.dereference) resolvedSrc = path$10.resolve(process.cwd(), resolvedSrc);
+		if (!destStat) return fs.symlink(resolvedSrc, dest);
+		let resolvedDest = null;
+		try {
+			resolvedDest = await fs.readlink(dest);
+		} catch (e) {
+			if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs.symlink(resolvedSrc, dest);
+			throw e;
+		}
+		if (opts.dereference) resolvedDest = path$10.resolve(process.cwd(), resolvedDest);
+		if (resolvedSrc !== resolvedDest) {
+			if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+			if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+		}
+		await fs.unlink(dest);
+		return fs.symlink(resolvedSrc, dest);
+	}
+	module.exports = copy;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const path$9 = __require("path");
+	const mkdirsSync = require_mkdirs().mkdirsSync;
+	const utimesMillisSync = require_utimes().utimesMillisSync;
+	const stat = require_stat();
+	function copySync(src, dest, opts) {
+		if (typeof opts === "function") opts = { filter: opts };
+		opts = opts || {};
+		opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+		opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+		if (opts.preserveTimestamps && process.arch === "ia32") process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0002");
+		const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
+		stat.checkParentPathsSync(src, srcStat, dest, "copy");
+		if (opts.filter && !opts.filter(src, dest)) return;
+		const destParent = path$9.dirname(dest);
+		if (!fs.existsSync(destParent)) mkdirsSync(destParent);
+		return getStats(destStat, src, dest, opts);
+	}
+	function getStats(destStat, src, dest, opts) {
+		const srcStat = (opts.dereference ? fs.statSync : fs.lstatSync)(src);
+		if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+		else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+		else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+		else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+		else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+		throw new Error(`Unknown file: ${src}`);
+	}
+	function onFile(srcStat, destStat, src, dest, opts) {
+		if (!destStat) return copyFile(srcStat, src, dest, opts);
+		return mayCopyFile(srcStat, src, dest, opts);
+	}
+	function mayCopyFile(srcStat, src, dest, opts) {
+		if (opts.overwrite) {
+			fs.unlinkSync(dest);
+			return copyFile(srcStat, src, dest, opts);
+		} else if (opts.errorOnExist) throw new Error(`'${dest}' already exists`);
+	}
+	function copyFile(srcStat, src, dest, opts) {
+		fs.copyFileSync(src, dest);
+		if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+		return setDestMode(dest, srcStat.mode);
+	}
+	function handleTimestamps(srcMode, src, dest) {
+		if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+		return setDestTimestamps(src, dest);
+	}
+	function fileIsNotWritable(srcMode) {
+		return (srcMode & 128) === 0;
+	}
+	function makeFileWritable(dest, srcMode) {
+		return setDestMode(dest, srcMode | 128);
+	}
+	function setDestMode(dest, srcMode) {
+		return fs.chmodSync(dest, srcMode);
+	}
+	function setDestTimestamps(src, dest) {
+		const updatedSrcStat = fs.statSync(src);
+		return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+	}
+	function onDir(srcStat, destStat, src, dest, opts) {
+		if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
+		return copyDir(src, dest, opts);
+	}
+	function mkDirAndCopy(srcMode, src, dest, opts) {
+		fs.mkdirSync(dest);
+		copyDir(src, dest, opts);
+		return setDestMode(dest, srcMode);
+	}
+	function copyDir(src, dest, opts) {
+		const dir = fs.opendirSync(src);
+		try {
+			let dirent;
+			while ((dirent = dir.readSync()) !== null) copyDirItem(dirent.name, src, dest, opts);
+		} finally {
+			dir.closeSync();
+		}
+	}
+	function copyDirItem(item, src, dest, opts) {
+		const srcItem = path$9.join(src, item);
+		const destItem = path$9.join(dest, item);
+		if (opts.filter && !opts.filter(srcItem, destItem)) return;
+		const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
+		return getStats(destStat, srcItem, destItem, opts);
+	}
+	function onLink(destStat, src, dest, opts) {
+		let resolvedSrc = fs.readlinkSync(src);
+		if (opts.dereference) resolvedSrc = path$9.resolve(process.cwd(), resolvedSrc);
+		if (!destStat) return fs.symlinkSync(resolvedSrc, dest);
+		else {
+			let resolvedDest;
+			try {
+				resolvedDest = fs.readlinkSync(dest);
+			} catch (err) {
+				if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs.symlinkSync(resolvedSrc, dest);
+				throw err;
+			}
+			if (opts.dereference) resolvedDest = path$9.resolve(process.cwd(), resolvedDest);
+			if (resolvedSrc !== resolvedDest) {
+				if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+				if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+			}
+			return copyLink(resolvedSrc, dest);
+		}
+	}
+	function copyLink(resolvedSrc, dest) {
+		fs.unlinkSync(dest);
+		return fs.symlinkSync(resolvedSrc, dest);
+	}
+	module.exports = copySync;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/copy/index.js
+var require_copy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	module.exports = {
+		copy: u(require_copy$1()),
+		copySync: require_copy_sync()
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/remove/index.js
+var require_remove = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const u = require_universalify().fromCallback;
+	function remove(path$14, callback) {
+		fs.rm(path$14, {
+			recursive: true,
+			force: true
+		}, callback);
+	}
+	function removeSync(path$14) {
+		fs.rmSync(path$14, {
+			recursive: true,
+			force: true
+		});
+	}
+	module.exports = {
+		remove: u(remove),
+		removeSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/empty/index.js
+var require_empty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	const path$8 = __require("path");
+	const mkdir = require_mkdirs();
+	const remove = require_remove();
+	const emptyDir = u(async function emptyDir$2(dir) {
+		let items;
+		try {
+			items = await fs.readdir(dir);
+		} catch {
+			return mkdir.mkdirs(dir);
+		}
+		return Promise.all(items.map((item) => remove.remove(path$8.join(dir, item))));
+	});
+	function emptyDirSync(dir) {
+		let items;
+		try {
+			items = fs.readdirSync(dir);
+		} catch {
+			return mkdir.mkdirsSync(dir);
+		}
+		items.forEach((item) => {
+			item = path$8.join(dir, item);
+			remove.removeSync(item);
+		});
+	}
+	module.exports = {
+		emptyDirSync,
+		emptydirSync: emptyDirSync,
+		emptyDir,
+		emptydir: emptyDir
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/ensure/file.js
+var require_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path$7 = __require("path");
+	const fs = require_fs();
+	const mkdir = require_mkdirs();
+	async function createFile(file) {
+		let stats;
+		try {
+			stats = await fs.stat(file);
+		} catch {}
+		if (stats && stats.isFile()) return;
+		const dir = path$7.dirname(file);
+		let dirStats = null;
+		try {
+			dirStats = await fs.stat(dir);
+		} catch (err) {
+			if (err.code === "ENOENT") {
+				await mkdir.mkdirs(dir);
+				await fs.writeFile(file, "");
+				return;
+			} else throw err;
+		}
+		if (dirStats.isDirectory()) await fs.writeFile(file, "");
+		else await fs.readdir(dir);
+	}
+	function createFileSync(file) {
+		let stats;
+		try {
+			stats = fs.statSync(file);
+		} catch {}
+		if (stats && stats.isFile()) return;
+		const dir = path$7.dirname(file);
+		try {
+			if (!fs.statSync(dir).isDirectory()) fs.readdirSync(dir);
+		} catch (err) {
+			if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+			else throw err;
+		}
+		fs.writeFileSync(file, "");
+	}
+	module.exports = {
+		createFile: u(createFile),
+		createFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/ensure/link.js
+var require_link = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path$6 = __require("path");
+	const fs = require_fs();
+	const mkdir = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const { areIdentical } = require_stat();
+	async function createLink(srcpath, dstpath) {
+		let dstStat;
+		try {
+			dstStat = await fs.lstat(dstpath);
+		} catch {}
+		let srcStat;
+		try {
+			srcStat = await fs.lstat(srcpath);
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureLink");
+			throw err;
+		}
+		if (dstStat && areIdentical(srcStat, dstStat)) return;
+		const dir = path$6.dirname(dstpath);
+		if (!await pathExists(dir)) await mkdir.mkdirs(dir);
+		await fs.link(srcpath, dstpath);
+	}
+	function createLinkSync(srcpath, dstpath) {
+		let dstStat;
+		try {
+			dstStat = fs.lstatSync(dstpath);
+		} catch {}
+		try {
+			const srcStat = fs.lstatSync(srcpath);
+			if (dstStat && areIdentical(srcStat, dstStat)) return;
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureLink");
+			throw err;
+		}
+		const dir = path$6.dirname(dstpath);
+		if (fs.existsSync(dir)) return fs.linkSync(srcpath, dstpath);
+		mkdir.mkdirsSync(dir);
+		return fs.linkSync(srcpath, dstpath);
+	}
+	module.exports = {
+		createLink: u(createLink),
+		createLinkSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$5 = __require("path");
+	const fs = require_fs();
+	const { pathExists } = require_path_exists();
+	const u = require_universalify().fromPromise;
+	/**
+	* Function that returns two types of paths, one relative to symlink, and one
+	* relative to the current working directory. Checks if path is absolute or
+	* relative. If the path is relative, this function checks if the path is
+	* relative to symlink or relative to current working directory. This is an
+	* initiative to find a smarter `srcpath` to supply when building symlinks.
+	* This allows you to determine which path to use out of one of three possible
+	* types of source paths. The first is an absolute path. This is detected by
+	* `path.isAbsolute()`. When an absolute path is provided, it is checked to
+	* see if it exists. If it does it's used, if not an error is returned
+	* (callback)/ thrown (sync). The other two options for `srcpath` are a
+	* relative url. By default Node's `fs.symlink` works by creating a symlink
+	* using `dstpath` and expects the `srcpath` to be relative to the newly
+	* created symlink. If you provide a `srcpath` that does not exist on the file
+	* system it results in a broken symlink. To minimize this, the function
+	* checks to see if the 'relative to symlink' source file exists, and if it
+	* does it will use it. If it does not, it checks if there's a file that
+	* exists that is relative to the current working directory, if does its used.
+	* This preserves the expectations of the original fs.symlink spec and adds
+	* the ability to pass in `relative to current working direcotry` paths.
+	*/
+	async function symlinkPaths(srcpath, dstpath) {
+		if (path$5.isAbsolute(srcpath)) {
+			try {
+				await fs.lstat(srcpath);
+			} catch (err) {
+				err.message = err.message.replace("lstat", "ensureSymlink");
+				throw err;
+			}
+			return {
+				toCwd: srcpath,
+				toDst: srcpath
+			};
+		}
+		const dstdir = path$5.dirname(dstpath);
+		const relativeToDst = path$5.join(dstdir, srcpath);
+		if (await pathExists(relativeToDst)) return {
+			toCwd: relativeToDst,
+			toDst: srcpath
+		};
+		try {
+			await fs.lstat(srcpath);
+		} catch (err) {
+			err.message = err.message.replace("lstat", "ensureSymlink");
+			throw err;
+		}
+		return {
+			toCwd: srcpath,
+			toDst: path$5.relative(dstdir, srcpath)
+		};
+	}
+	function symlinkPathsSync(srcpath, dstpath) {
+		if (path$5.isAbsolute(srcpath)) {
+			if (!fs.existsSync(srcpath)) throw new Error("absolute srcpath does not exist");
+			return {
+				toCwd: srcpath,
+				toDst: srcpath
+			};
+		}
+		const dstdir = path$5.dirname(dstpath);
+		const relativeToDst = path$5.join(dstdir, srcpath);
+		if (fs.existsSync(relativeToDst)) return {
+			toCwd: relativeToDst,
+			toDst: srcpath
+		};
+		if (!fs.existsSync(srcpath)) throw new Error("relative srcpath does not exist");
+		return {
+			toCwd: srcpath,
+			toDst: path$5.relative(dstdir, srcpath)
+		};
+	}
+	module.exports = {
+		symlinkPaths: u(symlinkPaths),
+		symlinkPathsSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const u = require_universalify().fromPromise;
+	async function symlinkType(srcpath, type) {
+		if (type) return type;
+		let stats;
+		try {
+			stats = await fs.lstat(srcpath);
+		} catch {
+			return "file";
+		}
+		return stats && stats.isDirectory() ? "dir" : "file";
+	}
+	function symlinkTypeSync(srcpath, type) {
+		if (type) return type;
+		let stats;
+		try {
+			stats = fs.lstatSync(srcpath);
+		} catch {
+			return "file";
+		}
+		return stats && stats.isDirectory() ? "dir" : "file";
+	}
+	module.exports = {
+		symlinkType: u(symlinkType),
+		symlinkTypeSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const path$4 = __require("path");
+	const fs = require_fs();
+	const { mkdirs, mkdirsSync } = require_mkdirs();
+	const { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+	const { symlinkType, symlinkTypeSync } = require_symlink_type();
+	const { pathExists } = require_path_exists();
+	const { areIdentical } = require_stat();
+	async function createSymlink(srcpath, dstpath, type) {
+		let stats;
+		try {
+			stats = await fs.lstat(dstpath);
+		} catch {}
+		if (stats && stats.isSymbolicLink()) {
+			const [srcStat, dstStat] = await Promise.all([fs.stat(srcpath), fs.stat(dstpath)]);
+			if (areIdentical(srcStat, dstStat)) return;
+		}
+		const relative = await symlinkPaths(srcpath, dstpath);
+		srcpath = relative.toDst;
+		const toType = await symlinkType(relative.toCwd, type);
+		const dir = path$4.dirname(dstpath);
+		if (!await pathExists(dir)) await mkdirs(dir);
+		return fs.symlink(srcpath, dstpath, toType);
+	}
+	function createSymlinkSync(srcpath, dstpath, type) {
+		let stats;
+		try {
+			stats = fs.lstatSync(dstpath);
+		} catch {}
+		if (stats && stats.isSymbolicLink()) {
+			if (areIdentical(fs.statSync(srcpath), fs.statSync(dstpath))) return;
+		}
+		const relative = symlinkPathsSync(srcpath, dstpath);
+		srcpath = relative.toDst;
+		type = symlinkTypeSync(relative.toCwd, type);
+		const dir = path$4.dirname(dstpath);
+		if (fs.existsSync(dir)) return fs.symlinkSync(srcpath, dstpath, type);
+		mkdirsSync(dir);
+		return fs.symlinkSync(srcpath, dstpath, type);
+	}
+	module.exports = {
+		createSymlink: u(createSymlink),
+		createSymlinkSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { createFile, createFileSync } = require_file();
+	const { createLink, createLinkSync } = require_link();
+	const { createSymlink, createSymlinkSync } = require_symlink();
+	module.exports = {
+		createFile,
+		createFileSync,
+		ensureFile: createFile,
+		ensureFileSync: createFileSync,
+		createLink,
+		createLinkSync,
+		ensureLink: createLink,
+		ensureLinkSync: createLinkSync,
+		createSymlink,
+		createSymlinkSync,
+		ensureSymlink: createSymlink,
+		ensureSymlinkSync: createSymlinkSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/jsonfile@6.2.0/node_modules/jsonfile/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+		const EOF = finalEOL ? EOL : "";
+		return JSON.stringify(obj, replacer, spaces).replace(/\n/g, EOL) + EOF;
+	}
+	function stripBom(content) {
+		if (Buffer.isBuffer(content)) content = content.toString("utf8");
+		return content.replace(/^\uFEFF/, "");
+	}
+	module.exports = {
+		stringify,
+		stripBom
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/jsonfile@6.2.0/node_modules/jsonfile/index.js
+var require_jsonfile$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let _fs;
+	try {
+		_fs = require_graceful_fs();
+	} catch (_) {
+		_fs = __require("fs");
+	}
+	const universalify = require_universalify();
+	const { stringify, stripBom } = require_utils();
+	async function _readFile(file, options = {}) {
+		if (typeof options === "string") options = { encoding: options };
+		const fs$3 = options.fs || _fs;
+		const shouldThrow = "throws" in options ? options.throws : true;
+		let data = await universalify.fromCallback(fs$3.readFile)(file, options);
+		data = stripBom(data);
+		let obj;
+		try {
+			obj = JSON.parse(data, options ? options.reviver : null);
+		} catch (err) {
+			if (shouldThrow) {
+				err.message = `${file}: ${err.message}`;
+				throw err;
+			} else return null;
+		}
+		return obj;
+	}
+	const readFile = universalify.fromPromise(_readFile);
+	function readFileSync(file, options = {}) {
+		if (typeof options === "string") options = { encoding: options };
+		const fs$3 = options.fs || _fs;
+		const shouldThrow = "throws" in options ? options.throws : true;
+		try {
+			let content = fs$3.readFileSync(file, options);
+			content = stripBom(content);
+			return JSON.parse(content, options.reviver);
+		} catch (err) {
+			if (shouldThrow) {
+				err.message = `${file}: ${err.message}`;
+				throw err;
+			} else return null;
+		}
+	}
+	async function _writeFile(file, obj, options = {}) {
+		const fs$3 = options.fs || _fs;
+		const str = stringify(obj, options);
+		await universalify.fromCallback(fs$3.writeFile)(file, str, options);
+	}
+	const writeFile = universalify.fromPromise(_writeFile);
+	function writeFileSync(file, obj, options = {}) {
+		const fs$3 = options.fs || _fs;
+		const str = stringify(obj, options);
+		return fs$3.writeFileSync(file, str, options);
+	}
+	module.exports = {
+		readFile,
+		readFileSync,
+		writeFile,
+		writeFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const jsonFile = require_jsonfile$1();
+	module.exports = {
+		readJson: jsonFile.readFile,
+		readJsonSync: jsonFile.readFileSync,
+		writeJson: jsonFile.writeFile,
+		writeJsonSync: jsonFile.writeFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const fs = require_fs();
+	const path$3 = __require("path");
+	const mkdir = require_mkdirs();
+	const pathExists = require_path_exists().pathExists;
+	async function outputFile(file, data, encoding = "utf-8") {
+		const dir = path$3.dirname(file);
+		if (!await pathExists(dir)) await mkdir.mkdirs(dir);
+		return fs.writeFile(file, data, encoding);
+	}
+	function outputFileSync(file, ...args) {
+		const dir = path$3.dirname(file);
+		if (!fs.existsSync(dir)) mkdir.mkdirsSync(dir);
+		fs.writeFileSync(file, ...args);
+	}
+	module.exports = {
+		outputFile: u(outputFile),
+		outputFileSync
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { stringify } = require_utils();
+	const { outputFile } = require_output_file();
+	async function outputJson(file, data, options = {}) {
+		await outputFile(file, stringify(data, options), options);
+	}
+	module.exports = outputJson;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { stringify } = require_utils();
+	const { outputFileSync } = require_output_file();
+	function outputJsonSync(file, data, options) {
+		outputFileSync(file, stringify(data, options), options);
+	}
+	module.exports = outputJsonSync;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/json/index.js
+var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	const jsonFile = require_jsonfile();
+	jsonFile.outputJson = u(require_output_json());
+	jsonFile.outputJsonSync = require_output_json_sync();
+	jsonFile.outputJSON = jsonFile.outputJson;
+	jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+	jsonFile.writeJSON = jsonFile.writeJson;
+	jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+	jsonFile.readJSON = jsonFile.readJson;
+	jsonFile.readJSONSync = jsonFile.readJsonSync;
+	module.exports = jsonFile;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/move/move.js
+var require_move$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_fs();
+	const path$2 = __require("path");
+	const { copy } = require_copy();
+	const { remove } = require_remove();
+	const { mkdirp } = require_mkdirs();
+	const { pathExists } = require_path_exists();
+	const stat = require_stat();
+	async function move(src, dest, opts = {}) {
+		const overwrite = opts.overwrite || opts.clobber || false;
+		const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
+		await stat.checkParentPaths(src, srcStat, dest, "move");
+		const destParent = path$2.dirname(dest);
+		if (path$2.parse(destParent).root !== destParent) await mkdirp(destParent);
+		return doRename(src, dest, overwrite, isChangingCase);
+	}
+	async function doRename(src, dest, overwrite, isChangingCase) {
+		if (!isChangingCase) {
+			if (overwrite) await remove(dest);
+			else if (await pathExists(dest)) throw new Error("dest already exists.");
+		}
+		try {
+			await fs.rename(src, dest);
+		} catch (err) {
+			if (err.code !== "EXDEV") throw err;
+			await moveAcrossDevice(src, dest, overwrite);
+		}
+	}
+	async function moveAcrossDevice(src, dest, overwrite) {
+		await copy(src, dest, {
+			overwrite,
+			errorOnExist: true,
+			preserveTimestamps: true
+		});
+		return remove(src);
+	}
+	module.exports = move;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	const path$1 = __require("path");
+	const copySync = require_copy().copySync;
+	const removeSync = require_remove().removeSync;
+	const mkdirpSync = require_mkdirs().mkdirpSync;
+	const stat = require_stat();
+	function moveSync(src, dest, opts) {
+		opts = opts || {};
+		const overwrite = opts.overwrite || opts.clobber || false;
+		const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
+		stat.checkParentPathsSync(src, srcStat, dest, "move");
+		if (!isParentRoot(dest)) mkdirpSync(path$1.dirname(dest));
+		return doRename(src, dest, overwrite, isChangingCase);
+	}
+	function isParentRoot(dest) {
+		const parent = path$1.dirname(dest);
+		return path$1.parse(parent).root === parent;
+	}
+	function doRename(src, dest, overwrite, isChangingCase) {
+		if (isChangingCase) return rename(src, dest, overwrite);
+		if (overwrite) {
+			removeSync(dest);
+			return rename(src, dest, overwrite);
+		}
+		if (fs.existsSync(dest)) throw new Error("dest already exists.");
+		return rename(src, dest, overwrite);
+	}
+	function rename(src, dest, overwrite) {
+		try {
+			fs.renameSync(src, dest);
+		} catch (err) {
+			if (err.code !== "EXDEV") throw err;
+			return moveAcrossDevice(src, dest, overwrite);
+		}
+	}
+	function moveAcrossDevice(src, dest, overwrite) {
+		copySync(src, dest, {
+			overwrite,
+			errorOnExist: true,
+			preserveTimestamps: true
+		});
+		return removeSync(src);
+	}
+	module.exports = moveSync;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/move/index.js
+var require_move = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const u = require_universalify().fromPromise;
+	module.exports = {
+		move: u(require_move$1()),
+		moveSync: require_move_sync()
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/fs-extra@11.3.3/node_modules/fs-extra/lib/esm.mjs
+var import_copy = /* @__PURE__ */ __toESM(require_copy(), 1);
+var import_empty = /* @__PURE__ */ __toESM(require_empty(), 1);
+var import_ensure = /* @__PURE__ */ __toESM(require_ensure(), 1);
+var import_json = /* @__PURE__ */ __toESM(require_json(), 1);
+var import_mkdirs = /* @__PURE__ */ __toESM(require_mkdirs(), 1);
+var import_move = /* @__PURE__ */ __toESM(require_move(), 1);
+var import_output_file = /* @__PURE__ */ __toESM(require_output_file(), 1);
+var import_path_exists = /* @__PURE__ */ __toESM(require_path_exists(), 1);
+var import_remove = /* @__PURE__ */ __toESM(require_remove(), 1);
+const copy = import_copy.default.copy;
+const copySync = import_copy.default.copySync;
+const emptyDirSync = import_empty.default.emptyDirSync;
+const emptydirSync = import_empty.default.emptydirSync;
+const emptyDir$1 = import_empty.default.emptyDir;
+const emptydir = import_empty.default.emptydir;
+const createFile = import_ensure.default.createFile;
+const createFileSync = import_ensure.default.createFileSync;
+const ensureFile = import_ensure.default.ensureFile;
+const ensureFileSync = import_ensure.default.ensureFileSync;
+const createLink = import_ensure.default.createLink;
+const createLinkSync = import_ensure.default.createLinkSync;
+const ensureLink = import_ensure.default.ensureLink;
+const ensureLinkSync = import_ensure.default.ensureLinkSync;
+const createSymlink = import_ensure.default.createSymlink;
+const createSymlinkSync = import_ensure.default.createSymlinkSync;
+const ensureSymlink = import_ensure.default.ensureSymlink;
+const ensureSymlinkSync = import_ensure.default.ensureSymlinkSync;
+const readJson = import_json.default.readJson;
+const readJSON$1 = import_json.default.readJSON;
+const readJsonSync = import_json.default.readJsonSync;
+const readJSONSync = import_json.default.readJSONSync;
+const writeJson = import_json.default.writeJson;
+const writeJSON$1 = import_json.default.writeJSON;
+const writeJsonSync = import_json.default.writeJsonSync;
+const writeJSONSync = import_json.default.writeJSONSync;
+const outputJson = import_json.default.outputJson;
+const outputJSON = import_json.default.outputJSON;
+const outputJsonSync = import_json.default.outputJsonSync;
+const outputJSONSync = import_json.default.outputJSONSync;
+const mkdirs = import_mkdirs.default.mkdirs;
+const mkdirsSync = import_mkdirs.default.mkdirsSync;
+const mkdirp = import_mkdirs.default.mkdirp;
+const mkdirpSync = import_mkdirs.default.mkdirpSync;
+const ensureDir = import_mkdirs.default.ensureDir;
+const ensureDirSync = import_mkdirs.default.ensureDirSync;
+const move = import_move.default.move;
+const moveSync = import_move.default.moveSync;
+const outputFile = import_output_file.default.outputFile;
+const outputFileSync = import_output_file.default.outputFileSync;
+const pathExists = import_path_exists.default.pathExists;
+const pathExistsSync = import_path_exists.default.pathExistsSync;
+const remove = import_remove.default.remove;
+const removeSync = import_remove.default.removeSync;
+var esm_default = {
+	...import_copy.default,
+	...import_empty.default,
+	...import_ensure.default,
+	...import_json.default,
+	...import_mkdirs.default,
+	...import_move.default,
+	...import_output_file.default,
+	...import_path_exists.default,
+	...import_remove.default
+};
+
+//#endregion
+//#region src/utils/packageJson.ts
+async function getPackageDependencies(packageDir) {
+	const dependenciesList = [];
+	const packageJsonPath = path.join(packageDir, "package.json");
+	try {
+		log.info(`Reading package.json from: ${packageJsonPath}`);
+		const packageJson = await esm_default.readJSON(packageJsonPath);
+		if (packageJson.dependencies) for (const [name, version] of Object.entries(packageJson.dependencies)) dependenciesList.push({
+			name,
+			version,
+			type: "dependencies"
+		});
+		if (packageJson.devDependencies) for (const [name, version] of Object.entries(packageJson.devDependencies)) dependenciesList.push({
+			name,
+			version,
+			type: "devDependencies"
+		});
+		log.info(`Found ${dependenciesList.length} dependencies in ${packageJsonPath}`);
+		return dependenciesList;
+	} catch (err) {
+		handleError(err, `Failed to read or parse package.json at ${packageJsonPath}: `);
+		return [];
+	}
+}
+
+//#endregion
+//#region src/utils/promise.ts
+const nativeExceptions = [
+	EvalError,
+	RangeError,
+	ReferenceError,
+	SyntaxError,
+	TypeError,
+	URIError
+].filter((except) => typeof except === "function");
+function throwNative(error) {
+	for (const Exception of nativeExceptions) if (error instanceof Exception) throw error;
+}
+const safeAwait = async (promise) => {
+	try {
+		const data = await promise;
+		if (data instanceof Error) {
+			throwNative(data);
+			return [data];
+		}
+		return [void 0, data];
+	} catch (error) {
+		throwNative(error);
+		return [error];
+	}
+};
+
+//#endregion
+//#region src/utils/prompts.ts
+const createOptions = (options) => options.map((option) => ({
+	label: option.toString(),
+	value: option
+}));
+const createPrompt = (fn) => {
+	return async (options) => {
+		const result = await fn(options);
+		if (isCancel(result)) {
+			cancel("User cancelled");
+			exit(0);
+		}
+		return result;
+	};
+};
+const createShowList = createPrompt((options) => {
+	options.map((option) => {
+		return isString(option) ? option : option.label;
+	}).forEach((item) => {
+		log.show(item, { type: "step" });
+	});
+});
+const createSearch = ({ message, options }) => {
+	const fuse = new Fuse(options, { keys: ["label"] });
+	return search({
+		message,
+		source: (term) => {
+			if (!term) return options;
+			return fuse.search(term).map(({ item }) => item);
+		}
+	});
+};
+process.on("uncaughtException", (error) => {
+	if (error instanceof Error && error.name === "ExitPromptError") log.show("User cancelled", { type: "error" });
+	else throw error;
+});
+const createCheckbox = async (opts) => {
+	const result = await multiselect(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createNote = ({ message = "", title = "", opts }) => note(message, title, opts);
+const createConfirm = createPrompt(confirm);
+const createTasks = createPrompt(tasks);
+const createSelect = async (opts) => {
+	const result = await select(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createInput = async (opts) => {
+	const result = await text(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createGroupMultiSelect = async (opts) => {
+	const result = await groupMultiselect(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		process.exit(0);
+	}
+	return result;
+};
+const createGroup = async (opts) => {
+	const result = await group(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createSpinner = (message, options) => {
+	const s = spinner(options);
+	s.start(message);
+	return s;
+};
+const createTaskLog = (title, options) => taskLog({
+	title,
+	...options
+});
+
+//#endregion
+//#region src/utils/spinner.ts
+const BASE_OPTIONS = { timeout: 1e4 };
+const ora = (options) => {
+	if (!isString(options)) return instance(options);
+	return instance({
+		spinner: spinners.circleHalves,
+		text: chalk.green(options)
+	});
+};
+
+//#endregion
+//#region src/utils/workspace.ts
+async function findWorkspaceRoot(startDir = process.cwd()) {
+	let currentDir = startDir;
+	while (true) try {
+		await fs.access(path.join(currentDir, "pnpm-workspace.yaml"));
+		return currentDir;
+	} catch {
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) throw new Error("pnpm-workspace.yaml not found in any parent directory.");
+		currentDir = parentDir;
+	}
+}
+async function getWorkspaceDirs() {
+	const workspaceRoot = await findWorkspaceRoot();
+	try {
+		log.info(`Found workspace root at: ${workspaceRoot}`);
+		const workspaceConfigPath = path.join(workspaceRoot, "pnpm-workspace.yaml");
+		const configFileContent = await fs.readFile(workspaceConfigPath, "utf8");
+		const workspaceConfig = yaml.parse(configFileContent);
+		if (!workspaceConfig?.packages?.length) {
+			log.warn("No packages defined in pnpm-workspace.yaml or file is empty.");
+			return {
+				root: workspaceRoot,
+				packages: []
+			};
+		}
+		log.info(`Workspace package patterns: ${workspaceConfig.packages.join(", ")}`);
+		const dirs = [];
+		for (const pattern of workspaceConfig.packages) {
+			const packagePaths = await glob(pattern, {
+				cwd: workspaceRoot,
+				absolute: true
+			});
+			dirs.push(...packagePaths);
+		}
+		return {
+			root: workspaceRoot,
+			packages: filterDirList(dirs)
+		};
+	} catch (err) {
+		handleError(err, "Failed to get workspace dirs: ");
+		return {
+			root: workspaceRoot,
+			packages: []
+		};
+	}
+}
+async function getWorkspaceNames() {
+	const workspacePackages = [];
+	try {
+		const { root, packages } = await getWorkspaceDirs();
+		for (const packageDir of packages) {
+			const packageJson = readJSON(`${packageDir}/package.json`);
+			if (packageJson) workspacePackages.push({
+				name: packageJson.name,
+				path: path.relative(root, packageDir)
+			});
+			else log.warn(`Skipping directory ${packageDir} as package.json does not contain a name.`);
+		}
+		log.info(`Found ${workspacePackages.length} packages.`);
+		return workspacePackages;
+	} catch (err) {
+		handleError(err, "Failed to get workspace packages: ");
+		return [];
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const pkg = readPackage(import.meta, "..");
+
+//#endregion
+export { $, BASE_OPTIONS, CONFIG_NAME, Configstore, LOWEST_NODE_VERSION, addFiles, buildCommand, cached, checkCommand, checkFile, clearScreen, clearTerminal, colors, copyFile, createCheckbox, createCommand, createConfirm, createGroup, createGroupMultiSelect, createHelpExample, createInput, createNote, createOptions, createSearch, createSelect, createShowList, createSpinner, createStore, createTaskLog, createTasks, cwdPathname, deleteFile, deleteFiles, dirList, dirname, emptyDir, emptyDirs, exit, fileList, filename, filterDirList, getBrowserApps, getCurrentBranch, getDiffFiles, getGitStatus, getLocalBranches, getPackageDependencies, getWorkspaceDirs, getWorkspaceNames, glob, handleError, has, hasOwn, intro, isArray, isBoolean, isChinese, isDate, isDebug, isEmpty, isEmptyDir, isError, isFormData, isFunction, isMap, isNull, isNumber, isPlainObject, isPromise, isSet, isString, isSymbol, isURLSearchParams, isUndefined, loadConfig, loadEnv, log, logger, openBrowser, openBrowserApp, ora, outro, parseNames, pkg, progress, readFile, readGitignore, readJSON, readPackage, require$1 as require, safeAwait, sleep, stream, writeJSON, x, xASync, zx };
+//# sourceMappingURL=index.js.map