@lousy-agents/lint 5.17.2 → 5.17.4

package/dist/index.js

@@ -550,7 +550,7 @@ module.exports = function extend() {
 
 },
 8078(module) {
-function webpackEmptyAsyncContext(req) {
+function __rspack_empty_async_context(req) {
   // Here Promise.resolve().then() is used instead of new Promise() to prevent
   // uncaught exception popping up in devtools
   return Promise.resolve().then(function() {
@@ -559,10 +559,10 @@ function webpackEmptyAsyncContext(req) {
     throw e;
   });
 }
-webpackEmptyAsyncContext.keys = () => ([]);
-webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
-webpackEmptyAsyncContext.id = 8078;
-module.exports = webpackEmptyAsyncContext;
+__rspack_empty_async_context.keys = () => ([]);
+__rspack_empty_async_context.resolve = __rspack_empty_async_context;
+__rspack_empty_async_context.id = 8078;
+module.exports = __rspack_empty_async_context;
 
 
 },
@@ -34595,8 +34595,6 @@ const pathe_M_eThtNZ_path = (/* unused pure expression or super */ null && ({
 var lib_main = __webpack_require__(5599);
 // EXTERNAL MODULE: external "node:assert"
 var external_node_assert_ = __webpack_require__(4589);
-// EXTERNAL MODULE: external "node:v8"
-var external_node_v8_ = __webpack_require__(8877);
 ;// CONCATENATED MODULE: ../../node_modules/exsolve/dist/index.mjs
 
 
@@ -34604,9 +34602,6 @@ var external_node_v8_ = __webpack_require__(8877);
 
 
 
-
-
-//#region src/internal/builtins.ts
 const nodeBuiltins = [
 	"_http_agent",
 	"_http_client",
@@ -34677,12 +34672,8 @@ const nodeBuiltins = [
 	"worker_threads",
 	"zlib"
 ];
-
-//#endregion
-//#region src/internal/errors.ts
-const own$1 = {}.hasOwnProperty;
 const classRegExp = /^([A-Z][a-z\d]*)+$/;
-const kTypes = new Set([
+const kTypes = /* @__PURE__ */ new Set([
 	"string",
 	"function",
 	"number",
@@ -34694,83 +34685,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) {
+					external_node_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 (external_node_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;
-}
-/**
-* 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;
+			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) {
+					external_node_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(external_node_util_.format, null, args));
+				}
+				get ["constructor"]() {
+					return Base;
+				}
+				get [kIsNodeError]() {
+					return true;
+				}
+				toString() {
+					return `${this.name} [${key}]: ${this.message}`;
+				}
+			}
+			return NodeError;
+		}
 	}
-	Error.captureStackTrace(error);
-	if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
-	return error;
-});
+}
 function getMessage(key, parameters, self) {
 	const message = messages.get(key);
 	external_node_assert_.ok(message !== void 0, "expected `message` to be found");
@@ -34778,29 +34781,44 @@ function getMessage(key, parameters, self) {
 		external_node_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);
 	external_node_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(external_node_util_.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 `${(0,external_node_util_.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 `${(0,external_node_util_.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 = (0,external_node_util_.inspect)(value, { colors: false });
+			if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+			return `type ${type} (${inspected})`;
+		}
 	}
-	let inspected = (0,external_node_util_.inspect)(value, { colors: false });
-	if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
-	return `type ${typeof value} (${inspected})`;
 }
-const ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
+createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
 	external_node_assert_.ok(typeof name === "string", "'name' must be a string");
 	if (!Array.isArray(expected)) expected = [expected];
 	let message = "The ";
@@ -34824,7 +34842,7 @@ const ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected
 	if (instances.length > 0) {
 		const pos = types.indexOf("object");
 		if (pos !== -1) {
-			types.slice(pos, 1);
+			types.splice(pos, 1);
 			instances.push("Object");
 		}
 	}
@@ -34844,20 +34862,11 @@ const ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected
 	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("./");
@@ -34867,39 +34876,30 @@ 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);
-const ERR_NETWORK_IMPORT_DISALLOWED = 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);
-const ERR_INVALID_ARG_VALUE = createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
+createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
 	let inspected = (0,external_node_util_.inspect)(value);
 	if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
 	return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
 }, TypeError);
-
-//#endregion
-//#region src/internal/package-json-reader.ts
 const hasOwnProperty$1 = {}.hasOwnProperty;
 const dist_cache = /* @__PURE__ */ new Map();
 function read(jsonPath, { base, specifier }) {
@@ -34956,9 +34956,6 @@ function getPackageScopeConfig(resolved) {
 		type: "none"
 	};
 }
-
-//#endregion
-//#region src/internal/get-format.ts
 const dist_hasOwnProperty = {}.hasOwnProperty;
 const extensionFormatMap = {
 	__proto__: null,
@@ -34977,33 +34974,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 dist_extname(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 "";
 }
@@ -35016,11 +35005,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, (0,external_node_url_.fileURLToPath)(url));
 }
@@ -35029,9 +35019,6 @@ function defaultGetFormatWithoutErrors(url, context) {
 	if (!dist_hasOwnProperty.call(protocolHandlers, protocol)) return null;
 	return protocolHandlers[protocol](url, context, true) || null;
 }
-
-//#endregion
-//#region src/internal/resolve.ts
 const RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
 const dist_own = {}.hasOwnProperty;
 const invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
@@ -35056,19 +35043,11 @@ function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
 	if (!main) external_node_process_.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 (external_node_path_.resolve(packagePath, main) !== urlPath) external_node_process_.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 (0,external_node_fs_.statSync)(path$1);
+		return (0,external_node_fs_.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 dist_fileExists(url) {
 	const stats = (0,external_node_fs_.statSync)(url, { throwIfNoEntry: false });
 	const isFile = stats ? stats.isFile() : void 0;
@@ -35079,7 +35058,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 	if (packageConfig.main !== void 0) {
 		guess = new external_node_url_.URL(packageConfig.main, packageJsonUrl);
 		if (dist_fileExists(guess)) return guess;
-		const tries$1 = [
+		const tries = [
 			`./${packageConfig.main}.js`,
 			`./${packageConfig.main}.json`,
 			`./${packageConfig.main}.node`,
@@ -35087,9 +35066,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 external_node_url_.URL(tries$1[i$1], packageJsonUrl);
+		let i = -1;
+		while (++i < tries.length) {
+			guess = new external_node_url_.URL(tries[i], packageJsonUrl);
 			if (dist_fileExists(guess)) break;
 			guess = void 0;
 		}
@@ -35221,7 +35200,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) {
@@ -35241,7 +35220,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);
@@ -35315,7 +35294,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", (0,external_node_url_.fileURLToPath)(base));
+	if (name === "#" || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", (0,external_node_url_.fileURLToPath)(base));
 	let packageJsonUrl;
 	const packageConfig = getPackageScopeConfig(base);
 	if (packageConfig.exists) {
@@ -35349,10 +35328,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;
@@ -35387,12 +35362,12 @@ function packageResolve(specifier, base, conditions) {
 			packageJsonPath = (0,external_node_url_.fileURLToPath)(packageJsonUrl);
 			continue;
 		}
-		const packageConfig$1 = read(packageJsonPath, {
+		const packageConfig = read(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 external_node_url_.URL(packageSubpath, packageJsonUrl);
 	} while (packageJsonPath.length !== lastPath.length);
 	// removed by dead control flow
@@ -35410,21 +35385,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:";
@@ -35451,19 +35411,10 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
 	if (resolved.protocol !== "file:") return resolved;
 	return finalizeResolution(resolved, base, preserveSymlinks);
 }
-
-//#endregion
-//#region src/resolve.ts
-const DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
-const dist_isWindows = /* @__PURE__ */ (() => process.platform === "win32")();
-const globalCache = /* @__PURE__ */ (() => 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 dist_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;
@@ -35528,15 +35479,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;
@@ -35596,21 +35538,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";
@@ -35642,7 +35594,6 @@ function _parseInput(input) {
 	throw new TypeError("id must be a `string` or `URL`");
 }
 
-//#endregion
 
 // EXTERNAL MODULE: external "node:module"
 var external_node_module_ = __webpack_require__(8995);
@@ -46934,8 +46885,8 @@ __webpack_require__.r = (exports) => {
       // object to store loaded and loading chunks
       // undefined = chunk not loaded, null = chunk preloaded/prefetched
       // [resolve, Promise] = chunk loading, 0 = chunk loaded
-      var installedChunks = {410: 0,};
-      var installChunk = (data) => {
+      var moduleInstalledChunks = {410: 0,};
+      var moduleInstallChunk = (data) => {
     var __rspack_esm_ids = data.__rspack_esm_ids;
     var moreModules = data.__webpack_modules__;
     var __rspack_esm_runtime = data.__rspack_esm_runtime;
@@ -46950,17 +46901,17 @@ __webpack_require__.r = (exports) => {
     if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
     for (; i < __rspack_esm_ids.length; i++) {
         chunkId = __rspack_esm_ids[i];
-        if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
-            installedChunks[chunkId][0]();
+        if (__webpack_require__.o(moduleInstalledChunks, chunkId) && moduleInstalledChunks[chunkId]) {
+            moduleInstalledChunks[chunkId][0]();
         }
-        installedChunks[__rspack_esm_ids[i]] = 0;
+        moduleInstalledChunks[__rspack_esm_ids[i]] = 0;
     }
     
 };
 
         __webpack_require__.f.j = function (chunkId, promises) {
           // import() chunk loading for javascript
-var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
+var installedChunkData = __webpack_require__.o(moduleInstalledChunks, chunkId) ? moduleInstalledChunks[chunkId] : undefined;
 if (installedChunkData !== 0) { // 0 means "already installed".'
     // a Promise means "currently loading".
     if (installedChunkData) {
@@ -46968,18 +46919,19 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
     } else {
         if (true) {
             // setup Promise in chunk cache
-            var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, (e) => {
-                if (installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;
+            var promise = import("./" + __webpack_require__.u(chunkId)).then(moduleInstallChunk, (e) => {
+                if (moduleInstalledChunks[chunkId] !== 0) moduleInstalledChunks[chunkId] = undefined;
                 throw e;
             });
             var promise = Promise.race([promise, new Promise((resolve) => {
-                installedChunkData = installedChunks[chunkId] = [resolve];
+                installedChunkData = moduleInstalledChunks[chunkId] = [resolve];
             })]);
             promises.push(installedChunkData[1] = promise);
         }
         
     }
 }
+
         }
         // no external install chunk
 // no on chunks loaded