@maltty/cli 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/{utils-DlIJNGLQ.js → utils-ioeFEbm4.js}

@@ -1,7 +1,8 @@
-import { r as __toESM } from "./chunk-DsIazq42.js";
-import { i as toError, n as err, r as ok, t as attemptAsync } from "./attemptAsync-BdXzRSIT.js";
-import { a as isAbsolute$1, i as extname$2, l as resolve$1, n as basename$1, o as join$1, r as dirname$1, s as normalize, t as defu } from "./defu-BBwssjW3.js";
-import { n, t as r } from "./jsonc-DqZkfC3S.js";
+import { r as __toESM } from "./rolldown-runtime-C7HZzL1F.js";
+import { i as toError, n as err, r as ok, t as attemptAsync } from "./attemptAsync-D_oWcKfe.js";
+import { a as isAbsolute$1, i as extname$2, l as resolve$1, n as basename$1, o as join$1, r as dirname$1, s as normalize, t as defu } from "./defu-BOMYL43b.js";
+import { t as a } from "./_format-XTN-U4H5.js";
+import { t as r } from "./jsonc-B3DUZTiW.js";
 import path, { isAbsolute, resolve } from "node:path";
 import { readFile, rm } from "node:fs/promises";
 import { z } from "zod";
@@ -12,7 +13,6 @@ import { format, inspect } from "node:util";
 import { homedir } from "node:os";
 import assert from "node:assert";
 import process$1 from "node:process";
-import v8 from "node:v8";
 //#region ../utils/dist/tag.js
 /**
 * Property key used to brand objects with a tag string.
@@ -43,7 +43,7 @@ function withTag(obj, tag) {
 	return copy;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/exsolve@1.0.8/node_modules/exsolve/dist/index.mjs
+//#region ../../node_modules/.pnpm/exsolve@1.1.1/node_modules/exsolve/dist/index.mjs
 const nodeBuiltins = [
 	"_http_agent",
 	"_http_client",
@@ -114,9 +114,8 @@ const nodeBuiltins = [
 	"worker_threads",
 	"zlib"
 ];
-const own$1 = {}.hasOwnProperty;
 const classRegExp = /^([A-Z][a-z\d]*)+$/;
-const kTypes = new Set([
+const kTypes = /* @__PURE__ */ new Set([
 	"string",
 	"function",
 	"number",
@@ -128,83 +127,95 @@ const kTypes = new Set([
 	"symbol"
 ]);
 const messages = /* @__PURE__ */ new Map();
-const nodeInternalPrefix = "__node_internal_";
-let userStackTraceLimit;
-/**
-* Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
-* We cannot use Intl.ListFormat because it's not available in
-* --without-intl builds.
-*
-* @param {Array<string>} array
-*   An array of strings.
-* @param {string} [type]
-*   The list type to be inserted before the last element.
-* @returns {string}
-*/
 function formatList(array, type = "and") {
-	return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array.at(-1)}`;
+	switch (array.length) {
+		case 0: return "";
+		case 1: return `${array[0]}`;
+		case 2: return `${array[0]} ${type} ${array[1]}`;
+		case 3: return `${array[0]}, ${array[1]}, ${type} ${array[2]}`;
+		default: return `${array.slice(0, -1).join(", ")}, ${type} ${array.at(-1)}`;
+	}
+}
+function getExpectedArgumentLength(message) {
+	let expectedLength = 0;
+	const regex = /%[dfijoOs]/g;
+	while (regex.exec(message) !== null) expectedLength++;
+	return expectedLength;
 }
-/**
-* Utility function for registering the error codes.
-*/
 function createError(sym, value, constructor) {
 	messages.set(sym, value);
 	return makeNodeErrorWithCode(constructor, sym);
 }
+const kIsNodeError = Symbol("kIsNodeError");
 function makeNodeErrorWithCode(Base, key) {
-	return function NodeError(...parameters) {
-		const limit = Error.stackTraceLimit;
-		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
-		const error = new Base();
-		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
-		const message = getMessage(key, parameters, error);
-		Object.defineProperties(error, {
-			message: {
-				value: message,
-				enumerable: false,
-				writable: true,
-				configurable: true
-			},
-			toString: {
-				value() {
+	const message = messages.get(key);
+	const expectedLength = typeof message === "string" ? getExpectedArgumentLength(message) : -1;
+	switch (expectedLength) {
+		case 0: {
+			class NodeError extends Base {
+				code = key;
+				constructor(...args) {
+					assert.ok(args.length === 0, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`);
+					super(message);
+				}
+				get ["constructor"]() {
+					return Base;
+				}
+				get [kIsNodeError]() {
+					return true;
+				}
+				toString() {
 					return `${this.name} [${key}]: ${this.message}`;
-				},
-				enumerable: false,
-				writable: true,
-				configurable: true
+				}
 			}
-		});
-		captureLargerStackTrace(error);
-		error.code = key;
-		return error;
-	};
-}
-function isErrorStackTraceLimitWritable() {
-	try {
-		if (v8.startupSnapshot.isBuildingSnapshot()) return false;
-	} catch {}
-	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
-	if (desc === void 0) return Object.isExtensible(Error);
-	return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+			return NodeError;
+		}
+		case -1: {
+			class NodeError extends Base {
+				code = key;
+				constructor(...args) {
+					super();
+					Object.defineProperty(this, "message", {
+						value: getMessage(key, args, this),
+						enumerable: false,
+						writable: true,
+						configurable: true
+					});
+				}
+				get ["constructor"]() {
+					return Base;
+				}
+				get [kIsNodeError]() {
+					return true;
+				}
+				toString() {
+					return `${this.name} [${key}]: ${this.message}`;
+				}
+			}
+			return NodeError;
+		}
+		default: {
+			class NodeError extends Base {
+				code = key;
+				constructor(...args) {
+					assert.ok(args.length === expectedLength, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`);
+					args.unshift(message);
+					super(Reflect.apply(format, null, args));
+				}
+				get ["constructor"]() {
+					return Base;
+				}
+				get [kIsNodeError]() {
+					return true;
+				}
+				toString() {
+					return `${this.name} [${key}]: ${this.message}`;
+				}
+			}
+			return NodeError;
+		}
+	}
 }
-/**
-* This function removes unnecessary frames from Node.js core errors.
-*/
-function hideStackFrames(wrappedFunction) {
-	const hidden = nodeInternalPrefix + wrappedFunction.name;
-	Object.defineProperty(wrappedFunction, "name", { value: hidden });
-	return wrappedFunction;
-}
-const captureLargerStackTrace = hideStackFrames(function(error) {
-	const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
-	if (stackTraceLimitIsWritable) {
-		userStackTraceLimit = Error.stackTraceLimit;
-		Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-	}
-	Error.captureStackTrace(error);
-	if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
-	return error;
-});
 function getMessage(key, parameters, self) {
 	const message = messages.get(key);
 	assert.ok(message !== void 0, "expected `message` to be found");
@@ -212,27 +223,42 @@ function getMessage(key, parameters, self) {
 		assert.ok(message.length <= parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`);
 		return Reflect.apply(message, self, parameters);
 	}
-	const regex = /%[dfijoOs]/g;
-	let expectedLength = 0;
-	while (regex.exec(message) !== null) expectedLength++;
+	const expectedLength = getExpectedArgumentLength(message);
 	assert.ok(expectedLength === parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`);
 	if (parameters.length === 0) return message;
 	parameters.unshift(message);
 	return Reflect.apply(format, null, parameters);
 }
-/**
-* Determine the specific type of a value for type-mismatch errors.
-*/
 function determineSpecificType(value) {
-	if (value === null || value === void 0) return String(value);
-	if (typeof value === "function" && value.name) return `function ${value.name}`;
-	if (typeof value === "object") {
-		if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
-		return `${inspect(value, { depth: -1 })}`;
+	if (value === null) return "null";
+	else if (value === void 0) return "undefined";
+	const type = typeof value;
+	switch (type) {
+		case "bigint": return `type bigint (${value}n)`;
+		case "number":
+			if (value === 0) return 1 / value === Number.NEGATIVE_INFINITY ? "type number (-0)" : "type number (0)";
+			else if (Number.isNaN(value)) return "type number (NaN)";
+			else if (value === Number.POSITIVE_INFINITY) return "type number (Infinity)";
+			else if (value === Number.NEGATIVE_INFINITY) return "type number (-Infinity)";
+			return `type number (${value})`;
+		case "boolean": return value ? "type boolean (true)" : "type boolean (false)";
+		case "symbol": return `type symbol (${String(value)})`;
+		case "function": return `function ${value.name}`;
+		case "object":
+			if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
+			return `${inspect(value, { depth: -1 })}`;
+		case "string": {
+			let string = value;
+			if (string.length > 28) string = `${string.slice(0, 25)}...`;
+			if (!string.includes("'")) return `type string ('${string}')`;
+			return `type string (${JSON.stringify(string)})`;
+		}
+		default: {
+			let inspected = inspect(value, { colors: false });
+			if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+			return `type ${type} (${inspected})`;
+		}
 	}
-	let inspected = inspect(value, { colors: false });
-	if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
-	return `type ${typeof value} (${inspected})`;
 }
 createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
 	assert.ok(typeof name === "string", "'name' must be a string");
@@ -258,7 +284,7 @@ createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
 	if (instances.length > 0) {
 		const pos = types.indexOf("object");
 		if (pos !== -1) {
-			types.slice(pos, 1);
+			types.splice(pos, 1);
 			instances.push("Object");
 		}
 	}
@@ -278,20 +304,11 @@ createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
 	message += `. Received ${determineSpecificType(actual)}`;
 	return message;
 }, TypeError);
-const ERR_INVALID_MODULE_SPECIFIER = createError(
-	"ERR_INVALID_MODULE_SPECIFIER",
-	/**
-	* @param {string} request
-	* @param {string} reason
-	* @param {string} [base]
-	*/
-	(request, reason, base) => {
-		return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
-	},
-	TypeError
-);
-const ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path$1, base, message) => {
-	return `Invalid package config ${path$1}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+const ERR_INVALID_MODULE_SPECIFIER = createError("ERR_INVALID_MODULE_SPECIFIER", (request, reason, base) => {
+	return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+}, TypeError);
+const ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path, base, message) => {
+	return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
 }, Error);
 const ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (packagePath, key, target, isImport = false, base) => {
 	const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
@@ -301,30 +318,24 @@ const ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (pa
 	}
 	return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
 }, Error);
-const ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", (path$1, base, exactUrl = false) => {
-	return `Cannot find ${exactUrl ? "module" : "package"} '${path$1}' imported from ${base}`;
+const ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", function(path, base, exactUrl = false) {
+	if (exactUrl && typeof exactUrl === "string") this.url = `${exactUrl}`;
+	return `Cannot find ${exactUrl ? "module" : "package"} '${path}' imported from ${base}`;
 }, Error);
-createError("ERR_NETWORK_IMPORT_DISALLOWED", "import of '%s' by %s is not supported: %s", Error);
 const ERR_PACKAGE_IMPORT_NOT_DEFINED = createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => {
 	return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath || ""}package.json` : ""} imported from ${base}`;
 }, TypeError);
-const ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
-	"ERR_PACKAGE_PATH_NOT_EXPORTED",
-	/**
-	* @param {string} packagePath
-	* @param {string} subpath
-	* @param {string} [base]
-	*/
-	(packagePath, subpath, base) => {
-		if (subpath === ".") return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
-		return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
-	},
-	Error
-);
-const ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
+const ERR_PACKAGE_PATH_NOT_EXPORTED = createError("ERR_PACKAGE_PATH_NOT_EXPORTED", (packagePath, subpath, base) => {
+	if (subpath === ".") return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+	return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+}, Error);
+const ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", function(path, base, exactUrl = void 0) {
+	this.url = exactUrl;
+	return `Directory import '${path}' is not supported resolving ES modules imported from ${base}`;
+}, Error);
 const ERR_UNSUPPORTED_RESOLVE_REQUEST = createError("ERR_UNSUPPORTED_RESOLVE_REQUEST", "Failed to resolve module specifier \"%s\" from \"%s\": Invalid relative URL or base scheme is not hierarchical.", TypeError);
-const ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", (extension, path$1) => {
-	return `Unknown file extension "${extension}" for ${path$1}`;
+const ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", (extension, path) => {
+	return `Unknown file extension "${extension}" for ${path}`;
 }, TypeError);
 createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
 	let inspected = inspect(value);
@@ -405,33 +416,25 @@ const protocolHandlers = {
 	"node:": () => "builtin"
 };
 function mimeToFormat(mime) {
-	if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime)) return "module";
+	if (mime && /^\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?$/i.test(mime)) return "module";
 	if (mime === "application/json") return "json";
 	return null;
 }
 function getDataProtocolModuleFormat(parsed) {
-	const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [
+	const { 1: mime } = /^([^/]+\/[^;,]+)(?:[^,]*?)(;base64)?,/.exec(parsed.pathname) || [
 		null,
 		null,
 		null
 	];
 	return mimeToFormat(mime);
 }
-/**
-* Returns the file extension from a URL.
-*
-* Should give similar result to
-* `require('node:path').extname(require('node:url').fileURLToPath(url))`
-* when used with a `file:` URL.
-*
-*/
+const DOT_CODE = 46;
+const SLASH_CODE = 47;
 function extname$1(url) {
 	const pathname = url.pathname;
-	let index = pathname.length;
-	while (index--) {
-		const code = pathname.codePointAt(index);
-		if (code === 47) return "";
-		if (code === 46) return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
+	for (let i = pathname.length - 1; i > 0; i--) switch (pathname.charCodeAt(i)) {
+		case SLASH_CODE: return "";
+		case DOT_CODE: return pathname.charCodeAt(i - 1) === SLASH_CODE ? "" : pathname.slice(i);
 	}
 	return "";
 }
@@ -444,11 +447,12 @@ function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
 	}
 	if (ext === "") {
 		const { type: packageType } = getPackageScopeConfig(url);
-		if (packageType === "none" || packageType === "commonjs") return "commonjs";
-		return "module";
+		if (packageType === "module") return "module";
+		if (packageType !== "none") return packageType;
+		return "commonjs";
 	}
-	const format$1 = extensionFormatMap[ext];
-	if (format$1) return format$1;
+	const format = extensionFormatMap[ext];
+	if (format) return format;
 	if (ignoreErrors) return;
 	throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath(url));
 }
@@ -481,19 +485,11 @@ function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
 	if (!main) process$1.emitWarning(`No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
 	else if (path.resolve(packagePath, main) !== urlPath) process$1.emitWarning(`Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
 }
-function tryStatSync(path$1) {
+function tryStatSync(path) {
 	try {
-		return statSync(path$1);
+		return statSync(path);
 	} catch {}
 }
-/**
-* Legacy CommonJS main resolution:
-* 1. let M = pkg_url + (json main field)
-* 2. TRY(M, M.js, M.json, M.node)
-* 3. TRY(M/index.js, M/index.json, M/index.node)
-* 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
-* 5. NOT_FOUND
-*/
 function fileExists(url) {
 	const stats = statSync(url, { throwIfNoEntry: false });
 	const isFile = stats ? stats.isFile() : void 0;
@@ -504,7 +500,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 	if (packageConfig.main !== void 0) {
 		guess = new URL$1(packageConfig.main, packageJsonUrl);
 		if (fileExists(guess)) return guess;
-		const tries$1 = [
+		const tries = [
 			`./${packageConfig.main}.js`,
 			`./${packageConfig.main}.json`,
 			`./${packageConfig.main}.node`,
@@ -512,9 +508,9 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 			`./${packageConfig.main}/index.json`,
 			`./${packageConfig.main}/index.node`
 		];
-		let i$1 = -1;
-		while (++i$1 < tries$1.length) {
-			guess = new URL$1(tries$1[i$1], packageJsonUrl);
+		let i = -1;
+		while (++i < tries.length) {
+			guess = new URL$1(tries[i], packageJsonUrl);
 			if (fileExists(guess)) break;
 			guess = void 0;
 		}
@@ -646,7 +642,7 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
 			}
 			return resolveResult;
 		}
-		if (lastException === void 0 || lastException === null) return null;
+		if (lastException === void 0 || lastException === null) return lastException;
 		throw lastException;
 	}
 	if (typeof target === "object" && target !== null) {
@@ -666,7 +662,7 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
 				return resolveResult;
 			}
 		}
-		return null;
+		return;
 	}
 	if (target === null) return null;
 	throw invalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base);
@@ -740,7 +736,7 @@ function patternKeyCompare(a, b) {
 	return 0;
 }
 function packageImportsResolve(name, base, conditions) {
-	if (name === "#" || name.startsWith("#/") || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", fileURLToPath(base));
+	if (name === "#" || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", fileURLToPath(base));
 	let packageJsonUrl;
 	const packageConfig = getPackageScopeConfig(base);
 	if (packageConfig.exists) {
@@ -757,7 +753,7 @@ function packageImportsResolve(name, base, conditions) {
 			while (++i < keys.length) {
 				const key = keys[i];
 				const patternIndex = key.indexOf("*");
-				if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
+				if (patternIndex !== -1 && name.startsWith(key.slice(0, patternIndex))) {
 					const patternTrailer = key.slice(patternIndex + 1);
 					if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
 						bestMatch = key;
@@ -774,10 +770,6 @@ function packageImportsResolve(name, base, conditions) {
 	}
 	throw importNotDefined(name, packageJsonUrl, base);
 }
-/**
-* @param {string} specifier
-* @param {URL} base
-*/
 function parsePackageName(specifier, base) {
 	let separatorIndex = specifier.indexOf("/");
 	let validPackageName = true;
@@ -812,12 +804,12 @@ function packageResolve(specifier, base, conditions) {
 			packageJsonPath = fileURLToPath(packageJsonUrl);
 			continue;
 		}
-		const packageConfig$1 = read$1(packageJsonPath, {
+		const packageConfig = read$1(packageJsonPath, {
 			base,
 			specifier
 		});
-		if (packageConfig$1.exports !== void 0 && packageConfig$1.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig$1, base, conditions);
-		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig$1, base);
+		if (packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
+		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig, base);
 		return new URL$1(packageSubpath, packageJsonUrl);
 	} while (packageJsonPath.length !== lastPath.length);
 	throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base), false);
@@ -834,21 +826,6 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
 	if (specifier[0] === "/") return true;
 	return isRelativeSpecifier(specifier);
 }
-/**
-* The “Resolver Algorithm Specification” as detailed in the Node docs (which is
-* sync and slightly lower-level than `resolve`).
-*
-* @param {string} specifier
-*   `/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`, etc.
-* @param {URL} base
-*   Full URL (to a file) that `specifier` is resolved relative from.
-* @param {Set<string>} [conditions]
-*   Conditions.
-* @param {boolean} [preserveSymlinks]
-*   Keep symlinks instead of resolving them.
-* @returns {URL}
-*   A URL object to the found thing.
-*/
 function moduleResolve(specifier, base, conditions, preserveSymlinks) {
 	const protocol = base.protocol;
 	const isData = protocol === "data:";
@@ -875,16 +852,10 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
 	if (resolved.protocol !== "file:") return resolved;
 	return finalizeResolution(resolved, base, preserveSymlinks);
 }
-const DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
-const isWindows = process.platform === "win32";
-const globalCache = globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map();
-/**
-* Synchronously resolves a module url based on the options provided.
-*
-* @param {string} input - The identifier or path of the module to resolve.
-* @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
-* @returns {string} The resolved URL as a string.
-*/
+const DEFAULT_CONDITIONS_SET = /* #__PURE__ */ new Set(["node", "import"]);
+const DEFAULT_CONDITIONS_KEY = "2:6:import4:node";
+const isWindows = /* #__PURE__ */ (() => process.platform === "win32")();
+const globalCache = /* #__PURE__ */ (() => globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map())();
 function resolveModuleURL(input, options) {
 	const parsedInput = _parseInput(input);
 	if ("external" in parsedInput) return parsedInput.external;
@@ -949,15 +920,6 @@ function resolveModuleURL(input, options) {
 	if (cacheObj) cacheObj.set(cacheKey, resolved.href);
 	return resolved.href;
 }
-/**
-* Synchronously resolves a module then converts it to a file path
-*
-* (throws error if reolved path is not file:// scheme)
-*
-* @param {string} id - The identifier or path of the module to resolve.
-* @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
-* @returns {string} The resolved URL as a string.
-*/
 function resolveModulePath(id, options) {
 	const resolved = resolveModuleURL(id, options);
 	if (!resolved) return;
@@ -994,21 +956,31 @@ function _fmtPath(input) {
 		return input;
 	}
 }
-function _cacheKey(id, opts) {
-	return JSON.stringify([
-		id,
-		(opts?.conditions || ["node", "import"]).sort(),
-		opts?.extensions,
-		opts?.from,
-		opts?.suffixes
-	]);
+function _cacheKey(id, options) {
+	let from;
+	if (Array.isArray(options?.from)) from = options.from;
+	else if (options?.from) from = [options.from];
+	return _cacheKeyValues([id]) + _conditionsKey(options?.conditions) + _cacheKeyValues(options?.extensions) + _cacheKeyValues(from) + _cacheKeyValues(options?.suffixes);
+}
+function _conditionsKey(conditions) {
+	if (!conditions) return DEFAULT_CONDITIONS_KEY;
+	return _cacheKeyValues([...new Set(conditions)].sort());
+}
+function _cacheKeyValues(values) {
+	if (!values) return "-";
+	let key = `${values.length}:`;
+	for (const value of values) {
+		const stringValue = String(value);
+		key += `${stringValue.length}:${stringValue}`;
+	}
+	return key;
 }
 function _join(a, b) {
 	if (!a || !b || b === "/") return a;
 	return (a.endsWith("/") ? a : a + "/") + (b.startsWith("/") ? b.slice(1) : b);
 }
-function _normalizeWinPath(path$1) {
-	return path$1.replace(/\\/g, "/").replace(/^[a-z]:\//, (r) => r.toUpperCase());
+function _normalizeWinPath(path) {
+	return path.replace(/\\/g, "/").replace(/^[a-z]:\//, (r) => r.toUpperCase());
 }
 function _isURL(input) {
 	return input instanceof URL || input?.constructor?.name === "URL";
@@ -1233,7 +1205,13 @@ function readUser(options) {
 	return read(options);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.mjs
+//#region ../../node_modules/.pnpm/confbox@0.2.4/node_modules/confbox/dist/_chunks/json.mjs
+function n(t, n) {
+	let r = JSON.parse(t, n?.reviver);
+	return a(t, r, n), r;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/pkg-types@2.3.1/node_modules/pkg-types/dist/index.mjs
 const defaultFindOptions = {
 	startingFrom: ".",
 	rootPattern: /^node_modules$/,
@@ -1257,12 +1235,12 @@ async function findFile(filename, _options = {}) {
 	if (leadingSlash) segments[0] = "/" + segments[0];
 	let root = segments.findIndex((r) => r.match(options.rootPattern));
 	if (root === -1) root = 0;
-	if (options.reverse) for (let index = root + 1; index <= segments.length; index++) for (const filename2 of filenames) {
-		const filePath = join$1(...segments.slice(0, index), filename2);
+	if (options.reverse) for (let index = root + 1; index <= segments.length; index++) for (const filename of filenames) {
+		const filePath = join$1(...segments.slice(0, index), filename);
 		if (await options.test(filePath)) return filePath;
 	}
-	else for (let index = segments.length; index > root; index--) for (const filename2 of filenames) {
-		const filePath = join$1(...segments.slice(0, index), filename2);
+	else for (let index = segments.length; index > root; index--) for (const filename of filenames) {
+		const filePath = join$1(...segments.slice(0, index), filename);
 		if (await options.test(filePath)) return filePath;
 	}
 	throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
@@ -1349,12 +1327,7 @@ async function findWorkspaceDir(id = process.cwd(), options = {}) {
 	throw new Error(`Cannot detect workspace root from ${id}`);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/c12@4.0.0-beta.4_chokidar@5.0.0_dotenv@17.4.2_giget@1.2.5_jiti@2.7.0_magicast@0.5.2/node_modules/c12/dist/index.mjs
-/**
-* Load and interpolate environment variables into `process.env`.
-* If you need more control (or access to the values), consider using `loadDotenv` instead
-*
-*/
+//#region ../../node_modules/.pnpm/c12@4.0.0-beta.5_chokidar@5.0.0_dotenv@17.4.2_giget@1.2.5_jiti@2.7.0_magicast@0.5.3/node_modules/c12/dist/index.mjs
 async function setupDotenv(options) {
 	const targetEnvironment = options.env ?? process.env;
 	const environment = await loadDotenv({
@@ -1371,7 +1344,6 @@ async function setupDotenv(options) {
 	}
 	return environment;
 }
-/** Load environment variables into an object. */
 async function loadDotenv(options) {
 	const environment = Object.create(null);
 	const cwd = resolve$1(options.cwd || ".");
@@ -1408,7 +1380,7 @@ let _parseEnv = nodeUtil.parseEnv;
 async function readEnvFile(path) {
 	const src = readFileSync(path, "utf8");
 	if (!_parseEnv) try {
-		const dotenv = await import("./main-C_8x2aB3.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+		const dotenv = await import("./main-CMmTVJ4V.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
 		_parseEnv = (src) => dotenv.parse(src);
 	} catch {
 		throw new Error("Failed to parse .env file: `node:util.parseEnv` is not available and `dotenv` package is not installed. Please upgrade your runtime or install `dotenv` as a dependency.");
@@ -1451,11 +1423,11 @@ function getDotEnvVars(targetEnvironment) {
 const _normalize = (p) => p?.replace(/\\/g, "/");
 let importCounter = 0;
 const ASYNC_LOADERS = {
-	".yaml": () => import("./yaml-BS9RDuUr.js").then((r) => r.parseYAML),
-	".yml": () => import("./yaml-BS9RDuUr.js").then((r) => r.parseYAML),
-	".jsonc": () => import("./jsonc-KADMdSjU.js").then((r) => r.parseJSONC),
-	".json5": () => import("./json5-z-PGDMyy.js").then((r) => r.parseJSON5),
-	".toml": () => import("./toml-LuHsHQtV.js").then((r) => r.parseTOML)
+	".yaml": () => import("./yaml-Cp5SldPx.js").then((r) => r.parseYAML),
+	".yml": () => import("./yaml-Cp5SldPx.js").then((r) => r.parseYAML),
+	".jsonc": () => import("./jsonc-BjIiMOLf.js").then((r) => r.parseJSONC),
+	".json5": () => import("./json5-Dgws4cj9.js").then((r) => r.parseJSON5),
+	".toml": () => import("./toml-BrfNstp2.js").then((r) => r.parseTOML)
 };
 const SUPPORTED_EXTENSIONS = Object.freeze([
 	".js",
@@ -1633,12 +1605,12 @@ async function resolveConfig(source, options, sourceOptions = {}) {
 	}
 	const _merger = options.merger || defu;
 	const customProviderKeys = Object.keys(sourceOptions.giget?.providers || {}).map((key) => `${key}:`);
-	const gigetPrefixes = customProviderKeys.length > 0 ? [...new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
+	const gigetPrefixes = customProviderKeys.length > 0 ? [.../* @__PURE__ */ new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
 	if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
-		const { downloadTemplate } = await import("./dist-Xa07jNxS.js").catch((error) => {
+		const { downloadTemplate } = await import("./dist-BGEDDbkB.js").catch((error) => {
 			throw new Error(`Extending config from \`${source}\` requires \`giget\` peer dependency to be installed.\n\nInstall it with: \`npx nypm i giget\``, { cause: error });
 		});
-		const { digest } = await import("./ohash-BPoV4zBH.js").then((n) => n.n);
+		const { digest } = await import("./ohash-Cgvv31gH.js").then((n) => n.n);
 		const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
 		let cloneDir;
 		const localNodeModules = resolve$1(options.cwd, "node_modules");
@@ -1680,13 +1652,14 @@ async function resolveConfig(source, options, sourceOptions = {}) {
 			const _configURL = pathToFileURL(res.configFile);
 			_configURL.search = `_${++importCounter}`;
 			res.config = await import(_configURL.href).then(_resolveModule, async (error) => {
-				const { createJiti } = await import("./jiti-CxWlVmZ_.js").catch(() => {
+				const { createJiti } = await import("./jiti-DLiXBetA.js").catch(() => {
 					throw new Error(`Failed to load config file \`${res.configFile}\`: ${error?.message}.  Hint install \`jiti\` for compatibility.`, { cause: error });
 				});
 				const jiti = createJiti(join$1(options.cwd || ".", options.configFile || "/"), {
 					interopDefault: true,
 					moduleCache: false,
-					extensions: [...SUPPORTED_EXTENSIONS]
+					extensions: [...SUPPORTED_EXTENSIONS],
+					...options.jitiOptions
 				});
 				options.import = (id) => jiti.import(id);
 				return _resolveModule(await options.import(res.configFile));
@@ -1718,7 +1691,6 @@ function tryResolve(id, options) {
 	});
 	return res ? normalize(res) : void 0;
 }
-/** Returns `true`/`false` if the path exists, `null` if it doesn't. */
 function _isDirectory(path) {
 	try {
 		return statSync(path).isDirectory();
@@ -1902,4 +1874,4 @@ async function loadConfig(options) {
 //#endregion
 export { loadConfig as n, compileTargets as t };
 
-//# sourceMappingURL=utils-DlIJNGLQ.js.map
+//# sourceMappingURL=utils-ioeFEbm4.js.map