react-doctor 0.9.1 → 0.9.2-dev.01ca0b3

package/dist/lsp.js

@@ -10,12 +10,14 @@ import * as Crypto from "node:crypto";
 import crypto, { createHash } from "node:crypto";
 import * as NodeChildProcess from "node:child_process";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { ResolverFactory } from "oxc-resolver";
 import ts from "typescript";
-import { parseJSON5 } from "confbox";
 import * as NodeUrl from "node:url";
 import { fileURLToPath } from "node:url";
+import { parseJSON5 } from "confbox";
 import { createJiti } from "jiti";
 import { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "deslop-js/analyzed-inputs";
+import { convertToTSX } from "@astrojs/compiler/sync";
 import { gzipSync } from "node:zlib";
 import { CodeActionKind, CodeActionTriggerKind, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FileChangeType, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node.js";
 import { TextDocument } from "vscode-languageserver-textdocument";
@@ -10279,7 +10281,7 @@ const Number$4 = globalThis.Number;
 * @category constructors
 * @since 2.0.0
 */
-const parse = (s) => {
+const parse$1 = (s) => {
 	if (s === "NaN") return some(NaN);
 	if (s === "Infinity") return some(Infinity);
 	if (s === "-Infinity") return some(-Infinity);
@@ -14333,12 +14335,12 @@ TaggedError("EncodingError");
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.70/node_modules/effect/dist/internal/schema/annotations.js
 /** @internal */
-function resolve(ast) {
+function resolve$1(ast) {
 	return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
 }
 /** @internal */
 function resolveAt(key) {
-	return (ast) => resolve(ast)?.[key];
+	return (ast) => resolve$1(ast)?.[key];
 }
 /** @internal */
 const resolveIdentifier = /* @__PURE__ */ resolveAt("identifier");
@@ -18090,7 +18092,7 @@ function asSync(parser) {
 }
 const recur$1 = /* @__PURE__ */ memoize((ast) => {
 	let parser;
-	const astOptions = resolve(ast)?.["parseOptions"];
+	const astOptions = resolve$1(ast)?.["parseOptions"];
 	if (!ast.context && !ast.encoding && !ast.checks) return (ou, options) => {
 		parser ??= ast.getParser(recur$1);
 		if (astOptions) options = {
@@ -57695,7 +57697,7 @@ var UrlParamsError = class extends TaggedError("UrlParamsError") {};
 * @category converting
 * @since 4.0.0
 */
-const makeUrl = (url, params, hash) => {
+const makeUrl$1 = (url, params, hash) => {
 	try {
 		const urlInstance = new URL(url, baseUrl());
 		for (let i = 0; i < params.params.length; i++) {
@@ -58329,7 +58331,7 @@ const Proto$2 = {
 const make$10 = (f) => makeWith$1((effect) => flatMap$2(effect, (request) => withFiber((fiber) => {
 	const scopedController = scopedRequests.get(request);
 	const controller = scopedController ?? new AbortController();
-	const urlResult = makeUrl(request.url, request.urlParams, getOrUndefined(request.hash));
+	const urlResult = makeUrl$1(request.url, request.urlParams, getOrUndefined(request.hash));
 	if (isFailure(urlResult)) return fail$4(new HttpClientError({ reason: new InvalidUrlError({
 		request,
 		cause: urlResult.failure
@@ -58768,7 +58770,7 @@ const layer$7 = (loggers, options) => effect(CurrentLoggers, withFiber$1(fnUntra
 * @since 4.0.0
 */
 const policy = /* @__PURE__ */ forever$1.pipe(passthrough$2, /* @__PURE__ */ addDelay((error) => {
-	if (isHttpClientError(error) && error.reason._tag === "StatusCodeError" && error.reason.response.status === 429) return succeed$2(seconds(fromUndefinedOr(error.reason.response.headers["retry-after"]).pipe(flatMap$5(parse), getOrElse$1(() => 5))));
+	if (isHttpClientError(error) && error.reason._tag === "StatusCodeError" && error.reason.response.status === 429) return succeed$2(seconds(fromUndefinedOr(error.reason.response.headers["retry-after"]).pipe(flatMap$5(parse$1), getOrElse$1(() => 5))));
 	return succeed$2(seconds(1));
 }));
 /**
@@ -61410,6 +61412,428 @@ const layer = /* @__PURE__ */ succeed$3(Path$1)({
 	toFileUrl
 });
 //#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+	return a[0] - b[0];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: 7
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url = parseAbsoluteUrl("http:" + input);
+		url.scheme = "";
+		url.type = 6;
+		return url;
+	}
+	if (isAbsolutePath(input)) {
+		const url = parseAbsoluteUrl("http://foo.com" + input);
+		url.scheme = "";
+		url.host = "";
+		url.type = 5;
+		return url;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath(base, base.type);
+	if (url.path === "/") url.path = base.path;
+	else url.path = stripPathFilename(base.path) + url.path;
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath(url, type) {
+	const rel = type <= 4;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) pieces[pointer++] = piece;
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) path += "/" + pieces[i];
+	if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== 7) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case 1: url.hash = baseUrl.hash;
+			case 2: url.query = baseUrl.query;
+			case 3:
+			case 4: mergePaths(url, baseUrl);
+			case 5:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case 6: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case 2:
+		case 3: return queryHash;
+		case 4: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+			return path + queryHash;
+		}
+		case 5: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+	const from = stripFilename(mapUrl);
+	const prefix = sourceRoot ? sourceRoot + "/" : "";
+	return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) mappings[i] = sortSegments(mappings[i], owned);
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) if (!isSorted(mappings[i])) return i;
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) if (line[j][COLUMN] < line[j - 1][COLUMN]) return false;
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+	return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = parse(map);
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+		const resolve = resolver(mapUrl, sourceRoot);
+		this.resolvedSources = sources.map(resolve);
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = void 0;
+		} else if (Array.isArray(mappings)) {
+			this._encoded = void 0;
+			this._decoded = maybeSort(mappings, isString);
+		} else if (parsed.sections) throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+		else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+		this._decodedMemo = memoizedState();
+		this._bySources = void 0;
+		this._bySourceMemos = void 0;
+	}
+};
+function cast(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || 1);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === -1 ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === -1) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+//#endregion
 //#region ../core/dist/index.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -61478,7 +61902,8 @@ var AmbiguousProjectError = class extends Error {
 	}
 };
 const isProjectDiscoveryError = (value) => value instanceof ProjectNotFoundError || value instanceof NoReactDependencyError || value instanceof PackageJsonNotFoundError || value instanceof NotADirectoryError || value instanceof AmbiguousProjectError;
-const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?|mts|mjs)$/;
+const HTML_FILE_PATTERN = /\.html$/i;
+const SOURCE_FILE_PATTERN = /\.(?:astro|tsx?|jsx?|mts|mjs|[hH][tT][mM][lL])$/;
 const GENERATED_BUNDLE_FILE_PATTERN = /\.(iife|umd|global|min)\.m?js$/i;
 const GENERATED_SOURCE_DIRECTORY_PATTERN = /(?:^|\/)__generated__\//;
 const MINIFIED_SNIFF_BYTES = 65536;
@@ -61844,7 +62269,7 @@ const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
 const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
 const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
 const SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
-const CORE_PACKAGE_VERSION = "0.9.1";
+const CORE_PACKAGE_VERSION = "0.9.2";
 const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
@@ -62094,8 +62519,13 @@ const findMonorepoRoot = (startDirectory) => {
 * byte-equivalent copy.
 */
 const isProjectBoundary = (directory) => NFS.existsSync(Path.join(directory, ".git")) || isMonorepoRoot(directory);
+const unwrapTypescriptExpression = (expression) => {
+	let currentExpression = expression;
+	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
+	return currentExpression;
+};
 const TSCONFIG_FILENAME = "tsconfig.json";
-const isRelativeExtendsValue = (extendsValue) => extendsValue.startsWith("./") || extendsValue.startsWith("../") || Path.isAbsolute(extendsValue);
+const isLocalModuleSpecifier = (moduleSpecifier) => moduleSpecifier === "." || moduleSpecifier === ".." || moduleSpecifier.startsWith("./") || moduleSpecifier.startsWith("../") || Path.isAbsolute(moduleSpecifier);
 const ensureJsonExtension = (filePath) => Path.extname(filePath) === "" ? `${filePath}.json` : filePath;
 const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
 	const requireFromConfig = createRequire(Path.join(fromConfigDirectory, "tsconfig.json"));
@@ -62112,7 +62542,12 @@ const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
 	return null;
 };
 const resolveExtendsPath = (extendsValue, fromConfigDirectory) => {
-	if (isRelativeExtendsValue(extendsValue)) return ensureJsonExtension(Path.resolve(fromConfigDirectory, extendsValue));
+	if (isLocalModuleSpecifier(extendsValue)) {
+		const resolvedPath = Path.resolve(fromConfigDirectory, extendsValue);
+		if (isFile(resolvedPath)) return resolvedPath;
+		const directoryConfigPath = Path.join(resolvedPath, TSCONFIG_FILENAME);
+		return isFile(directoryConfigPath) ? directoryConfigPath : ensureJsonExtension(resolvedPath);
+	}
 	return resolvePackageExtendsPath(extendsValue, fromConfigDirectory);
 };
 const normalizeCompilerOptions = (compilerOptions) => {
@@ -62219,6 +62654,7 @@ const FRAMEWORK_PACKAGES = {
 	"@tanstack/react-start": "tanstack-start",
 	"@remix-run/react": "remix",
 	gatsby: "gatsby",
+	astro: "astro",
 	vite: "vite",
 	"react-scripts": "cra",
 	expo: "expo",
@@ -62306,6 +62742,15 @@ const REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS = [
 	".cts",
 	".json"
 ];
+const REACT_COMPILER_CONFIG_RESOLVER = new ResolverFactory({
+	conditionNames: [
+		"import",
+		"require",
+		"node",
+		"default"
+	],
+	extensions: REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS
+});
 const STATIC_EXPORT_OUTPUT_PATTERN = /(?:^|[^.\w])["']?output["']?\s*:\s*["']export["']/m;
 const hasCompilerPackage = (packageJson, compilerPackages) => {
 	const allDependencies = {
@@ -62329,6 +62774,18 @@ const hasCompilerPackageInAncestors = (directory, compilerPackages) => {
 	return false;
 };
 const resolveImportedConfigFile = (fromFilePath, moduleSpecifier) => {
+	if (!isLocalModuleSpecifier(moduleSpecifier)) {
+		try {
+			const resolvedPath = REACT_COMPILER_CONFIG_RESOLVER.resolveFileSync(fromFilePath, moduleSpecifier).path;
+			if (resolvedPath && isFile(resolvedPath)) return resolvedPath;
+		} catch {}
+		try {
+			const resolvedPath = createRequire(fromFilePath).resolve(moduleSpecifier);
+			return isFile(resolvedPath) ? resolvedPath : null;
+		} catch {
+			return null;
+		}
+	}
 	const unresolvedPath = Path.resolve(Path.dirname(fromFilePath), moduleSpecifier);
 	const extension = Path.extname(unresolvedPath);
 	return (extension ? [unresolvedPath, ...REACT_COMPILER_CONFIG_SOURCE_EXTENSIONS.map((sourceExtension) => `${unresolvedPath.slice(0, -extension.length)}${sourceExtension}`)] : [
@@ -62338,10 +62795,10 @@ const resolveImportedConfigFile = (fromFilePath, moduleSpecifier) => {
 	]).find(isFile) ?? null;
 };
 const parseConfigSourceFile = (filePath, content) => filePath.endsWith(".json") || Path.basename(filePath) === ".babelrc" ? ts.parseJsonText(filePath, content) : ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-const getStaticPropertyName$1 = (propertyName) => ts.isIdentifier(propertyName) || ts.isStringLiteralLike(propertyName) ? propertyName.text : ts.isComputedPropertyName(propertyName) && ts.isStringLiteralLike(propertyName.expression) ? propertyName.expression.text : null;
+const getStaticPropertyName$2 = (propertyName) => ts.isIdentifier(propertyName) || ts.isStringLiteralLike(propertyName) ? propertyName.text : ts.isComputedPropertyName(propertyName) && ts.isStringLiteralLike(propertyName.expression) ? propertyName.expression.text : null;
 const isCommonJsConfigExportAssignment = (node, sourceFile) => ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && (node.left.getText(sourceFile) === "module.exports" || node.left.getText(sourceFile) === "exports.default");
 const hasExportModifier = (node) => ts.canHaveModifiers(node) && Boolean(ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
-const getRequireModuleSpecifier = (expression) => {
+const getRequireModuleSpecifier$1 = (expression) => {
 	if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.expression.text !== "require" || expression.arguments.length !== 1) return null;
 	const moduleSpecifier = expression.arguments[0];
 	return moduleSpecifier && ts.isStringLiteralLike(moduleSpecifier) ? moduleSpecifier.text : null;
@@ -62354,7 +62811,7 @@ const hasTopLevelValueBinding = (sourceFile, bindingName) => sourceFile.statemen
 		const namedBindings = importClause?.namedBindings;
 		return namedBindings ? ts.isNamespaceImport(namedBindings) ? namedBindings.name.text === bindingName : namedBindings.elements.some((element) => element.name.text === bindingName) : false;
 	}
-	if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === bindingName);
+	if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => bindingNameContainsIdentifier(declaration.name, bindingName));
 	return (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name?.text === bindingName;
 });
 const getImportBinding = (sourceFile, bindingName) => {
@@ -62385,24 +62842,24 @@ const getImportBinding = (sourceFile, bindingName) => {
 		for (const declaration of statement.declarationList.declarations) {
 			if (!declaration.initializer) continue;
 			if (ts.isIdentifier(declaration.name) && declaration.name.text === bindingName) {
-				const directModuleSpecifier = getRequireModuleSpecifier(declaration.initializer);
+				const directModuleSpecifier = getRequireModuleSpecifier$1(declaration.initializer);
 				if (directModuleSpecifier) return {
 					moduleSpecifier: directModuleSpecifier,
 					exportName: "default",
 					isNamespace: true
 				};
-				if (ts.isPropertyAccessExpression(declaration.initializer) && getRequireModuleSpecifier(declaration.initializer.expression) !== null) return {
-					moduleSpecifier: getRequireModuleSpecifier(declaration.initializer.expression) ?? "",
+				if (ts.isPropertyAccessExpression(declaration.initializer) && getRequireModuleSpecifier$1(declaration.initializer.expression) !== null) return {
+					moduleSpecifier: getRequireModuleSpecifier$1(declaration.initializer.expression) ?? "",
 					exportName: declaration.initializer.name.text,
 					isNamespace: false
 				};
 			}
 			if (!ts.isObjectBindingPattern(declaration.name)) continue;
 			const bindingElement = declaration.name.elements.find((element) => ts.isIdentifier(element.name) && element.name.text === bindingName);
-			const moduleSpecifier = getRequireModuleSpecifier(declaration.initializer);
+			const moduleSpecifier = getRequireModuleSpecifier$1(declaration.initializer);
 			if (bindingElement && moduleSpecifier) return {
 				moduleSpecifier,
-				exportName: bindingElement.propertyName ? getStaticPropertyName$1(bindingElement.propertyName) ?? bindingElement.propertyName.getText(sourceFile) : bindingElement.name.getText(sourceFile),
+				exportName: bindingElement.propertyName ? getStaticPropertyName$2(bindingElement.propertyName) ?? bindingElement.propertyName.getText(sourceFile) : bindingElement.name.getText(sourceFile),
 				isNamespace: false
 			};
 		}
@@ -62419,10 +62876,16 @@ const getTopLevelBinding = (sourceFile, bindingName) => {
 	}
 	return null;
 };
-const getFunctionLocalBindings = (functionNode, argumentsList) => {
+const getFunctionLocalBindings = (functionNode, argumentsList, argumentAnalysis, functionAnalysis) => {
 	const localBindings = /* @__PURE__ */ new Map();
 	functionNode.parameters.forEach((parameter, parameterIndex) => {
-		if (ts.isIdentifier(parameter.name)) localBindings.set(parameter.name.text, argumentsList[parameterIndex] ?? parameter.initializer ?? null);
+		if (ts.isIdentifier(parameter.name)) {
+			const argument = argumentsList[parameterIndex];
+			localBindings.set(parameter.name.text, {
+				expression: argument ?? parameter.initializer ?? null,
+				analysis: argument ? argumentAnalysis : functionAnalysis
+			});
+		}
 	});
 	return localBindings;
 };
@@ -62455,6 +62918,48 @@ const getScopedConfigBinding = (identifier) => {
 	};
 };
 const isCompilerTransformModule = (moduleSpecifier, exportName) => moduleSpecifier === "babel-plugin-react-compiler" && exportName === "default" || moduleSpecifier === "@vitejs/plugin-react" && exportName === "reactCompilerPreset";
+const NODE_MODULE_SPECIFIERS = new Set(["module", "node:module"]);
+const isConstantVariableInitializer = (node) => ts.isExpression(node) && ts.isVariableDeclaration(node.parent) && ts.isVariableDeclarationList(node.parent.parent) && Boolean(node.parent.parent.flags & ts.NodeFlags.Const);
+const isNodeCreateRequireCall = (node, analysis) => {
+	if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node) || ts.isAwaitExpression(node)) return isNodeCreateRequireCall(node.expression, analysis);
+	if (!ts.isCallExpression(node)) return false;
+	const target = node.expression;
+	if (ts.isIdentifier(target)) {
+		if (analysis.localBindings.has(target.text) || getScopedConfigBinding(target).wasFound) return false;
+		const importBinding = getImportBinding(analysis.sourceFile, target.text);
+		return Boolean(importBinding && NODE_MODULE_SPECIFIERS.has(importBinding.moduleSpecifier) && importBinding.exportName === "createRequire");
+	}
+	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return false;
+	if ((ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null) !== "createRequire") return false;
+	const createRequireReceiver = target.expression;
+	if (ts.isCallExpression(createRequireReceiver)) {
+		const requiredModuleSpecifier = getRequireModuleSpecifier$1(createRequireReceiver);
+		if (requiredModuleSpecifier === null || !NODE_MODULE_SPECIFIERS.has(requiredModuleSpecifier) || !ts.isIdentifier(createRequireReceiver.expression)) return false;
+		const requireIdentifier = createRequireReceiver.expression;
+		return !analysis.localBindings.has(requireIdentifier.text) && !getScopedConfigBinding(requireIdentifier).wasFound && !hasTopLevelValueBinding(analysis.sourceFile, requireIdentifier.text);
+	}
+	if (!ts.isIdentifier(createRequireReceiver)) return false;
+	if (analysis.localBindings.has(createRequireReceiver.text) || getScopedConfigBinding(createRequireReceiver).wasFound) return false;
+	const importBinding = getImportBinding(analysis.sourceFile, createRequireReceiver.text);
+	return Boolean(importBinding?.isNamespace && NODE_MODULE_SPECIFIERS.has(importBinding.moduleSpecifier));
+};
+const getNodeRequireResolveModuleSpecifier = (callExpression, analysis) => {
+	const [moduleSpecifierNode] = callExpression.arguments;
+	if (!moduleSpecifierNode || !ts.isStringLiteralLike(moduleSpecifierNode)) return null;
+	const target = callExpression.expression;
+	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return null;
+	if ((ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null) !== "resolve") return null;
+	if (isNodeCreateRequireCall(target.expression, analysis)) return moduleSpecifierNode.text;
+	if (!ts.isIdentifier(target.expression)) return null;
+	const resolverIdentifier = target.expression;
+	if (analysis.localBindings.has(resolverIdentifier.text)) return null;
+	const scopedBinding = getScopedConfigBinding(resolverIdentifier);
+	const topLevelBinding = scopedBinding.wasFound ? null : getTopLevelBinding(analysis.sourceFile, resolverIdentifier.text);
+	const resolverInitializer = scopedBinding.wasFound ? scopedBinding.initializer : topLevelBinding;
+	if (resolverInitializer === null && !scopedBinding.wasFound && resolverIdentifier.text === "require" && !hasTopLevelValueBinding(analysis.sourceFile, resolverIdentifier.text) && getImportBinding(analysis.sourceFile, resolverIdentifier.text) === null) return moduleSpecifierNode.text;
+	if (!resolverInitializer || !isConstantVariableInitializer(resolverInitializer) || !isNodeCreateRequireCall(resolverInitializer, analysis)) return null;
+	return moduleSpecifierNode.text;
+};
 const getAssignedPropertyInitializer = (identifier, propertyName) => {
 	let bindingScope = null;
 	let currentNode = identifier;
@@ -62497,9 +63002,11 @@ const getAssignedPropertyInitializer = (identifier, propertyName) => {
 		initializer: assignedInitializer
 	};
 };
-const getStaticConfigValueState = (expression, analysis) => {
-	let unwrappedExpression = expression;
-	while (ts.isParenthesizedExpression(unwrappedExpression) || ts.isAsExpression(unwrappedExpression) || ts.isTypeAssertionExpression(unwrappedExpression) || ts.isSatisfiesExpression(unwrappedExpression) || ts.isNonNullExpression(unwrappedExpression)) unwrappedExpression = unwrappedExpression.expression;
+const getStaticConfigValueState = (expression, analysis, visitedExpressions = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (visitedExpressions.has(unwrappedExpression)) return null;
+	const nextVisitedExpressions = new Set(visitedExpressions);
+	nextVisitedExpressions.add(unwrappedExpression);
 	if (unwrappedExpression.kind === ts.SyntaxKind.NullKeyword || ts.isIdentifier(unwrappedExpression) && unwrappedExpression.text === "undefined") return {
 		isNullish: true,
 		isTruthy: false
@@ -62514,32 +63021,32 @@ const getStaticConfigValueState = (expression, analysis) => {
 	};
 	if (ts.isIdentifier(unwrappedExpression)) {
 		if (analysis.localBindings.has(unwrappedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(unwrappedExpression.text);
-			return localInitializer ? getStaticConfigValueState(localInitializer, analysis) : null;
+			const localReference = analysis.localBindings.get(unwrappedExpression.text);
+			return localReference?.expression ? getStaticConfigValueState(localReference.expression, localReference.analysis, nextVisitedExpressions) : null;
 		}
 		const topLevelBinding = getTopLevelBinding(analysis.sourceFile, unwrappedExpression.text);
-		return topLevelBinding && ts.isExpression(topLevelBinding) ? getStaticConfigValueState(topLevelBinding, analysis) : null;
+		return topLevelBinding && ts.isExpression(topLevelBinding) ? getStaticConfigValueState(topLevelBinding, analysis, nextVisitedExpressions) : null;
 	}
 	if (ts.isConditionalExpression(unwrappedExpression)) {
-		const conditionState = getStaticConfigValueState(unwrappedExpression.condition, analysis);
-		if (conditionState !== null) return getStaticConfigValueState(conditionState.isTruthy ? unwrappedExpression.whenTrue : unwrappedExpression.whenFalse, analysis);
-		const whenTrueState = getStaticConfigValueState(unwrappedExpression.whenTrue, analysis);
-		const whenFalseState = getStaticConfigValueState(unwrappedExpression.whenFalse, analysis);
+		const conditionState = getStaticConfigValueState(unwrappedExpression.condition, analysis, nextVisitedExpressions);
+		if (conditionState !== null) return getStaticConfigValueState(conditionState.isTruthy ? unwrappedExpression.whenTrue : unwrappedExpression.whenFalse, analysis, nextVisitedExpressions);
+		const whenTrueState = getStaticConfigValueState(unwrappedExpression.whenTrue, analysis, nextVisitedExpressions);
+		const whenFalseState = getStaticConfigValueState(unwrappedExpression.whenFalse, analysis, nextVisitedExpressions);
 		return whenTrueState !== null && whenFalseState !== null && whenTrueState.isNullish === whenFalseState.isNullish && whenTrueState.isTruthy === whenFalseState.isTruthy ? whenTrueState : null;
 	}
 	if (ts.isBinaryExpression(unwrappedExpression)) {
-		const leftState = getStaticConfigValueState(unwrappedExpression.left, analysis);
+		const leftState = getStaticConfigValueState(unwrappedExpression.left, analysis, nextVisitedExpressions);
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
 			if (leftState === null) return null;
-			return leftState.isTruthy ? getStaticConfigValueState(unwrappedExpression.right, analysis) : leftState;
+			return leftState.isTruthy ? getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions) : leftState;
 		}
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
 			if (leftState === null) return null;
-			return leftState.isTruthy ? leftState : getStaticConfigValueState(unwrappedExpression.right, analysis);
+			return leftState.isTruthy ? leftState : getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions);
 		}
 		if (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
 			if (leftState === null) return null;
-			return leftState.isNullish ? getStaticConfigValueState(unwrappedExpression.right, analysis) : leftState;
+			return leftState.isNullish ? getStaticConfigValueState(unwrappedExpression.right, analysis, nextVisitedExpressions) : leftState;
 		}
 	}
 	return null;
@@ -62548,25 +63055,27 @@ const isStaticallyDisabledConfigExpression = (expression, analysis) => getStatic
 const isStaticallyTruthyConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isTruthy === true;
 const isStaticallyNullishConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isNullish === true;
 const isStaticallyNonNullishConfigExpression = (expression, analysis) => getStaticConfigValueState(expression, analysis)?.isNullish === false;
-const getReactCompilerFlagState = (expression, analysis) => {
-	let unwrappedExpression = expression;
-	while (ts.isParenthesizedExpression(unwrappedExpression) || ts.isAsExpression(unwrappedExpression) || ts.isTypeAssertionExpression(unwrappedExpression) || ts.isSatisfiesExpression(unwrappedExpression) || ts.isNonNullExpression(unwrappedExpression)) unwrappedExpression = unwrappedExpression.expression;
+const getReactCompilerFlagState = (expression, analysis, visitedExpressions = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (visitedExpressions.has(unwrappedExpression)) return null;
+	const nextVisitedExpressions = new Set(visitedExpressions);
+	nextVisitedExpressions.add(unwrappedExpression);
 	if (ts.isIdentifier(unwrappedExpression)) {
 		const assignedBinding = getAssignedPropertyInitializer(unwrappedExpression, "reactCompiler");
 		if (assignedBinding.wasFound && assignedBinding.initializer) return { isEnabled: !isStaticallyDisabledConfigExpression(assignedBinding.initializer, analysis) };
 		if (analysis.localBindings.has(unwrappedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(unwrappedExpression.text);
-			return localInitializer ? getReactCompilerFlagState(localInitializer, analysis) : null;
+			const localReference = analysis.localBindings.get(unwrappedExpression.text);
+			return localReference?.expression ? getReactCompilerFlagState(localReference.expression, localReference.analysis, nextVisitedExpressions) : null;
 		}
 		const topLevelBinding = getTopLevelBinding(analysis.sourceFile, unwrappedExpression.text);
-		return topLevelBinding && ts.isExpression(topLevelBinding) ? getReactCompilerFlagState(topLevelBinding, analysis) : null;
+		return topLevelBinding && ts.isExpression(topLevelBinding) ? getReactCompilerFlagState(topLevelBinding, analysis, nextVisitedExpressions) : null;
 	}
 	if (!ts.isObjectLiteralExpression(unwrappedExpression)) return null;
 	for (const property of [...unwrappedExpression.properties].reverse()) {
-		if (ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.initializer, analysis) };
+		if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.initializer, analysis) };
 		if (ts.isShorthandPropertyAssignment(property) && property.name.text === "reactCompiler") return { isEnabled: !isStaticallyDisabledConfigExpression(property.name, analysis) };
 		if (ts.isSpreadAssignment(property)) {
-			const spreadState = getReactCompilerFlagState(property.expression, analysis);
+			const spreadState = getReactCompilerFlagState(property.expression, analysis, nextVisitedExpressions);
 			if (spreadState) return spreadState;
 		}
 	}
@@ -62579,8 +63088,8 @@ const getSelectedObjectProperty = (expression, propertyName, analysis, visitedEx
 	visitedExpressions.add(resolvedExpression);
 	if (ts.isIdentifier(resolvedExpression)) {
 		if (analysis.localBindings.has(resolvedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(resolvedExpression.text);
-			return localInitializer ? getSelectedObjectProperty(localInitializer, propertyName, analysis, visitedExpressions) : null;
+			const localReference = analysis.localBindings.get(resolvedExpression.text);
+			return localReference?.expression ? getSelectedObjectProperty(localReference.expression, propertyName, localReference.analysis, visitedExpressions) : null;
 		}
 		const scopedBinding = getScopedConfigBinding(resolvedExpression);
 		if (scopedBinding.wasFound) return scopedBinding.initializer ? getSelectedObjectProperty(scopedBinding.initializer, propertyName, analysis, visitedExpressions) : null;
@@ -62589,9 +63098,18 @@ const getSelectedObjectProperty = (expression, propertyName, analysis, visitedEx
 	}
 	if (!ts.isObjectLiteralExpression(resolvedExpression)) return null;
 	for (const property of [...resolvedExpression.properties].reverse()) {
-		if (ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === propertyName) return property.initializer;
-		if (ts.isMethodDeclaration(property) && getStaticPropertyName$1(property.name) === propertyName) return property;
-		if (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName) return property.name;
+		if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === propertyName) return {
+			node: property.initializer,
+			analysis
+		};
+		if (ts.isMethodDeclaration(property) && getStaticPropertyName$2(property.name) === propertyName) return {
+			node: property,
+			analysis
+		};
+		if (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName) return {
+			node: property.name,
+			analysis
+		};
 		if (ts.isSpreadAssignment(property)) {
 			const spreadProperty = getSelectedObjectProperty(property.expression, propertyName, analysis, visitedExpressions);
 			if (spreadProperty) return spreadProperty;
@@ -62604,8 +63122,8 @@ const configExpressionMayDefineProperty = (expression, propertyName, analysis) =
 	while (ts.isParenthesizedExpression(resolvedExpression) || ts.isAsExpression(resolvedExpression) || ts.isTypeAssertionExpression(resolvedExpression) || ts.isSatisfiesExpression(resolvedExpression) || ts.isNonNullExpression(resolvedExpression)) resolvedExpression = resolvedExpression.expression;
 	if (ts.isIdentifier(resolvedExpression)) {
 		if (analysis.localBindings.has(resolvedExpression.text)) {
-			const localInitializer = analysis.localBindings.get(resolvedExpression.text);
-			return localInitializer ? configExpressionMayDefineProperty(localInitializer, propertyName, analysis) : true;
+			const localReference = analysis.localBindings.get(resolvedExpression.text);
+			return localReference?.expression ? configExpressionMayDefineProperty(localReference.expression, propertyName, localReference.analysis) : true;
 		}
 		const scopedBinding = getScopedConfigBinding(resolvedExpression);
 		if (scopedBinding.wasFound) return scopedBinding.initializer ? configExpressionMayDefineProperty(scopedBinding.initializer, propertyName, analysis) : true;
@@ -62621,7 +63139,7 @@ const configExpressionMayDefineProperty = (expression, propertyName, analysis) =
 	return resolvedExpression.properties.some((property) => {
 		if (ts.isSpreadAssignment(property)) return configExpressionMayDefineProperty(property.expression, propertyName, analysis);
 		if (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property) || ts.isMethodDeclaration(property) || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property)) {
-			const staticPropertyName = getStaticPropertyName$1(property.name);
+			const staticPropertyName = getStaticPropertyName$2(property.name);
 			return staticPropertyName === null || staticPropertyName === propertyName;
 		}
 		return false;
@@ -62640,7 +63158,7 @@ const getExportedConfigNodes = (sourceFile, exportName) => {
 			continue;
 		}
 		if (ts.isExpressionStatement(statement) && isCommonJsConfigExportAssignment(statement.expression, sourceFile) && exportName !== "default" && ts.isObjectLiteralExpression(statement.expression.right)) for (const property of [...statement.expression.right.properties].reverse()) {
-			if (ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === exportName) {
+			if (ts.isPropertyAssignment(property) && getStaticPropertyName$2(property.name) === exportName) {
 				exportedNodes.push(property.initializer);
 				break;
 			}
@@ -62689,15 +63207,15 @@ const getReExportedConfigModules = (sourceFile, exportName) => {
 	}
 	return bindings;
 };
-const analyzeConfigModuleExport = (filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = []) => {
+const analyzeConfigModuleExport = (filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = [], argumentAnalysis) => {
 	if (!isFile(filePath) || importDepth > 4) return false;
 	const moduleVisitKey = `${filePath}:${exportName}:${allowCompilerTransform}`;
 	if (visitedModules.has(moduleVisitKey)) return false;
 	const nextVisitedModules = new Set(visitedModules);
 	nextVisitedModules.add(moduleVisitKey);
-	return analyzeConfigSourceFileExport(parseConfigSourceFile(filePath, NFS.readFileSync(filePath, "utf-8")), filePath, exportName, allowCompilerTransform, importDepth, nextVisitedModules, argumentsList);
+	return analyzeConfigSourceFileExport(parseConfigSourceFile(filePath, NFS.readFileSync(filePath, "utf-8")), filePath, exportName, allowCompilerTransform, importDepth, nextVisitedModules, argumentsList, argumentAnalysis);
 };
-const analyzeConfigSourceFileExport = (sourceFile, filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = []) => {
+const analyzeConfigSourceFileExport = (sourceFile, filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = [], argumentAnalysis) => {
 	const analysis = {
 		filePath,
 		sourceFile,
@@ -62707,14 +63225,27 @@ const analyzeConfigSourceFileExport = (sourceFile, filePath, exportName, allowCo
 		localBindings: /* @__PURE__ */ new Map(),
 		activeFunctions: /* @__PURE__ */ new Set()
 	};
+	const resolvedArgumentAnalysis = argumentAnalysis ?? analysis;
 	const exportedConfigNodes = getExportedConfigNodes(sourceFile, exportName);
-	return exportedConfigNodes.some((node) => ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) ? analyzeConfigFunction(node, analysis, allowCompilerTransform, argumentsList) : analyzeConfigNode(node, analysis, allowCompilerTransform)) || getReExportedConfigModules(sourceFile, exportName).some((binding) => {
+	return exportedConfigNodes.some((node) => {
+		if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) return analyzeConfigFunction(node, analysis, allowCompilerTransform, argumentsList, resolvedArgumentAnalysis);
+		if (argumentsList.length > 0 && ts.isIdentifier(node)) {
+			const topLevelBinding = getTopLevelBinding(sourceFile, node.text);
+			if (topLevelBinding && ts.isFunctionLike(topLevelBinding)) return analyzeConfigFunction(topLevelBinding, analysis, allowCompilerTransform, argumentsList, resolvedArgumentAnalysis);
+			const importBinding = getImportBinding(sourceFile, node.text);
+			if (importBinding) {
+				const importedFilePath = resolveImportedConfigFile(filePath, importBinding.moduleSpecifier);
+				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, importDepth + 1, visitedModules, argumentsList, resolvedArgumentAnalysis));
+			}
+		}
+		return analyzeConfigNode(node, analysis, allowCompilerTransform);
+	}) || getReExportedConfigModules(sourceFile, exportName).some((binding) => {
 		if (exportedConfigNodes.length > 0 && binding.isNamespace) return false;
 		const importedFilePath = resolveImportedConfigFile(filePath, binding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, binding.exportName, allowCompilerTransform, importDepth + 1, visitedModules, argumentsList));
+		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, binding.exportName, allowCompilerTransform, importDepth + 1, visitedModules, argumentsList, resolvedArgumentAnalysis));
 	});
 };
-const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, argumentsList = []) => {
+const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, argumentsList = [], argumentAnalysis = analysis) => {
 	if (!functionNode.body) return false;
 	if (analysis.activeFunctions.has(functionNode.pos)) return false;
 	const activeFunctions = new Set(analysis.activeFunctions);
@@ -62722,7 +63253,7 @@ const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, a
 	const functionAnalysis = {
 		...analysis,
 		visitedNodes: /* @__PURE__ */ new Set(),
-		localBindings: getFunctionLocalBindings(functionNode, argumentsList),
+		localBindings: getFunctionLocalBindings(functionNode, argumentsList, argumentAnalysis, analysis),
 		activeFunctions
 	};
 	if (!ts.isBlock(functionNode.body)) return analyzeConfigNode(functionNode.body, functionAnalysis, allowCompilerTransform);
@@ -62738,6 +63269,11 @@ const analyzeConfigFunction = (functionNode, analysis, allowCompilerTransform, a
 	visitReturns(functionNode.body);
 	return hasCompiler;
 };
+const analyzeImportedConfig = ({ analysis, moduleSpecifier, exportName, allowCompilerTransform, argumentsList }) => {
+	const importedFilePath = resolveImportedConfigFile(analysis.filePath, moduleSpecifier);
+	if (!importedFilePath) return null;
+	return analyzeConfigModuleExport(importedFilePath, exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, argumentsList, analysis);
+};
 const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, isCompilerTransformCollection, excludedPropertyNames) => {
 	const assignedReactCompiler = getAssignedPropertyInitializer(identifier, "reactCompiler");
 	if (assignedReactCompiler.initializer && !isStaticallyDisabledConfigExpression(assignedReactCompiler.initializer, analysis)) return true;
@@ -62750,42 +63286,74 @@ const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, i
 	if (assignedPlugins.wasFound) overriddenPropertyNames.add("plugins");
 	if (assignedPresets.wasFound) overriddenPropertyNames.add("presets");
 	if (analysis.localBindings.has(identifier.text)) {
-		const localInitializer = analysis.localBindings.get(identifier.text);
-		return Boolean(localInitializer && analyzeConfigNode(localInitializer, analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
+		const localReference = analysis.localBindings.get(identifier.text);
+		return Boolean(localReference?.expression && analyzeConfigNode(localReference.expression, localReference.analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
 	}
 	const scopedBinding = getScopedConfigBinding(identifier);
 	if (scopedBinding.wasFound) return Boolean(scopedBinding.initializer && analyzeConfigNode(scopedBinding.initializer, analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
 	const importBinding = getImportBinding(analysis.sourceFile, identifier.text);
 	if (importBinding) {
 		if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, importBinding.exportName)) return true;
-		if (!importBinding.moduleSpecifier.startsWith(".")) return false;
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
+		return Boolean(analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: importBinding.moduleSpecifier,
+			exportName: importBinding.exportName,
+			allowCompilerTransform
+		}));
 	}
 	const topLevelBinding = getTopLevelBinding(analysis.sourceFile, identifier.text);
 	return Boolean(topLevelBinding && analyzeConfigNode(topLevelBinding, analysis, allowCompilerTransform, isCompilerTransformCollection, overriddenPropertyNames));
 };
 const analyzeConfigCallTarget = (callExpression, analysis, allowCompilerTransform) => {
 	const target = callExpression.expression;
+	const callableRequiredModuleSpecifier = getRequireModuleSpecifier$1(target);
+	if (callableRequiredModuleSpecifier !== null) {
+		if (ts.isCallExpression(target) && ts.isIdentifier(target.expression) && (analysis.localBindings.has(target.expression.text) || getScopedConfigBinding(target.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+		if (allowCompilerTransform && isCompilerTransformModule(callableRequiredModuleSpecifier, "default")) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: callableRequiredModuleSpecifier,
+			exportName: "default",
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(callableRequiredModuleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
+	}
 	if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return null;
 	const propertyName = ts.isPropertyAccessExpression(target) ? target.name.text : target.argumentExpression && ts.isStringLiteralLike(target.argumentExpression) ? target.argumentExpression.text : null;
 	if (propertyName === null) return null;
-	const requiredModuleSpecifier = getRequireModuleSpecifier(target.expression);
+	const requiredModuleSpecifier = getRequireModuleSpecifier$1(target.expression);
 	if (requiredModuleSpecifier !== null) {
-		if (ts.isCallExpression(target.expression) && ts.isIdentifier(target.expression.expression) && (getScopedConfigBinding(target.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
-		if (!requiredModuleSpecifier.startsWith(".")) return null;
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, requiredModuleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, propertyName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, callExpression.arguments));
+		if (ts.isCallExpression(target.expression) && ts.isIdentifier(target.expression.expression) && (analysis.localBindings.has(target.expression.expression.text) || getScopedConfigBinding(target.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+		if (allowCompilerTransform && isCompilerTransformModule(requiredModuleSpecifier, propertyName)) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: requiredModuleSpecifier,
+			exportName: propertyName,
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(requiredModuleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
 	}
 	if (!ts.isIdentifier(target.expression)) return null;
-	const importBinding = getImportBinding(analysis.sourceFile, target.expression.text);
-	if (importBinding?.isNamespace && importBinding.moduleSpecifier.startsWith(".")) {
-		const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-		return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, propertyName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, callExpression.arguments));
+	const importBinding = analysis.localBindings.has(target.expression.text) || getScopedConfigBinding(target.expression).wasFound ? null : getImportBinding(analysis.sourceFile, target.expression.text);
+	if (importBinding?.isNamespace) {
+		if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, propertyName)) return true;
+		const hasCompilerTransform = analyzeImportedConfig({
+			analysis,
+			moduleSpecifier: importBinding.moduleSpecifier,
+			exportName: propertyName,
+			allowCompilerTransform,
+			argumentsList: callExpression.arguments
+		});
+		if (isLocalModuleSpecifier(importBinding.moduleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+		return null;
 	}
 	const selectedProperty = getSelectedObjectProperty(target.expression, propertyName, analysis);
 	if (selectedProperty === null) return null;
-	return ts.isFunctionLike(selectedProperty) ? analyzeConfigFunction(selectedProperty, analysis, allowCompilerTransform, callExpression.arguments) : analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform);
+	return ts.isFunctionLike(selectedProperty.node) ? analyzeConfigFunction(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform, callExpression.arguments, analysis) : analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform);
 };
 const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTransformCollection = false, excludedPropertyNames) => {
 	const excludedPropertiesVisitKey = excludedPropertyNames ? [...excludedPropertyNames].sort().join(",") : "";
@@ -62799,25 +63367,29 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		const reactCompilerFlagState = excludedPropertyNames?.has("reactCompiler") ? null : getReactCompilerFlagState(node, analysis);
 		if (reactCompilerFlagState?.isEnabled) return true;
 		for (const [propertyIndex, property] of node.properties.entries()) if (ts.isPropertyAssignment(property)) {
-			const propertyName = getStaticPropertyName$1(property.name);
+			const propertyName = getStaticPropertyName$2(property.name);
 			if (propertyName && excludedPropertyNames?.has(propertyName)) continue;
 			if (propertyName === "reactCompiler") continue;
-			if ((propertyName === "plugins" || propertyName === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, propertyName, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$1(laterProperty.name) === propertyName)) continue;
+			if ((propertyName === "plugins" || propertyName === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, propertyName, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$2(laterProperty.name) === propertyName)) continue;
 			const propertyAllowsCompilerTransform = propertyName === "plugins" || propertyName === "presets";
-			if (propertyName === "extends" && ts.isStringLiteralLike(property.initializer) && property.initializer.text.startsWith(".")) {
-				const extendedFilePath = resolveImportedConfigFile(analysis.filePath, property.initializer.text);
-				if (extendedFilePath && analyzeConfigModuleExport(extendedFilePath, "default", false, analysis.importDepth + 1, analysis.visitedModules)) return true;
+			if (propertyName === "extends" && ts.isStringLiteralLike(property.initializer)) {
+				if (analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: property.initializer.text,
+					exportName: "default",
+					allowCompilerTransform: false
+				})) return true;
 			}
 			if (analyzeConfigNode(property.initializer, analysis, propertyAllowsCompilerTransform, propertyAllowsCompilerTransform)) return true;
 		} else if (ts.isShorthandPropertyAssignment(property)) {
 			if (excludedPropertyNames?.has(property.name.text)) continue;
 			if (property.name.text === "reactCompiler") continue;
-			if ((property.name.text === "plugins" || property.name.text === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, property.name.text, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$1(laterProperty.name) === property.name.text)) continue;
+			if ((property.name.text === "plugins" || property.name.text === "presets") && node.properties.slice(propertyIndex + 1).some((laterProperty) => ts.isSpreadAssignment(laterProperty) && configExpressionMayDefineProperty(laterProperty.expression, property.name.text, analysis) || (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && getStaticPropertyName$2(laterProperty.name) === property.name.text)) continue;
 			const propertyAllowsCompilerTransform = property.name.text === "plugins" || property.name.text === "presets";
 			if (analyzeConfigNode(property.name, analysis, propertyAllowsCompilerTransform, propertyAllowsCompilerTransform)) return true;
 		} else if (ts.isSpreadAssignment(property)) {
 			if (reactCompilerFlagState && getReactCompilerFlagState(property.expression, analysis) !== null) continue;
-			if (node.properties.slice(propertyIndex + 1).some((laterProperty) => (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && (getStaticPropertyName$1(laterProperty.name) === "plugins" || getStaticPropertyName$1(laterProperty.name) === "presets"))) continue;
+			if (node.properties.slice(propertyIndex + 1).some((laterProperty) => (ts.isPropertyAssignment(laterProperty) || ts.isShorthandPropertyAssignment(laterProperty)) && (getStaticPropertyName$2(laterProperty.name) === "plugins" || getStaticPropertyName$2(laterProperty.name) === "presets"))) continue;
 			if (analyzeConfigNode(property.expression, analysis, allowCompilerTransform, false, excludedPropertyNames)) return true;
 		}
 		return false;
@@ -62830,23 +63402,36 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		});
 	}
 	if (ts.isCallExpression(node)) {
+		const resolvedModuleSpecifier = getNodeRequireResolveModuleSpecifier(node, analysis);
+		if (resolvedModuleSpecifier !== null) return allowCompilerTransform && isCompilerTransformModule(resolvedModuleSpecifier, "default");
 		const callTargetResult = analyzeConfigCallTarget(node, analysis, allowCompilerTransform);
 		if (callTargetResult !== null) return callTargetResult;
-		const directModuleSpecifier = getRequireModuleSpecifier(node);
+		const directModuleSpecifier = getRequireModuleSpecifier$1(node);
 		const isRequireShadowed = analysis.localBindings.has("require") || ts.isIdentifier(node.expression) && getScopedConfigBinding(node.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require");
 		if (directModuleSpecifier && isRequireShadowed) return analyzeConfigNode(node.expression, analysis, allowCompilerTransform);
 		if (directModuleSpecifier && !isRequireShadowed) {
 			if (allowCompilerTransform && isCompilerTransformModule(directModuleSpecifier, "default")) return true;
-			if (directModuleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, directModuleSpecifier);
-				if (importedFilePath && analyzeConfigModuleExport(importedFilePath, "default", allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules)) return true;
-			}
+			if (analyzeImportedConfig({
+				analysis,
+				moduleSpecifier: directModuleSpecifier,
+				exportName: "default",
+				allowCompilerTransform
+			})) return true;
 		}
 		if (ts.isIdentifier(node.expression)) {
-			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
-			if (importBinding?.moduleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, importBinding.exportName, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules, node.arguments));
+			if (!analysis.localBindings.has(node.expression.text) && !getScopedConfigBinding(node.expression).wasFound) {
+				const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
+				if (importBinding) {
+					if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, importBinding.exportName)) return true;
+					const hasCompilerTransform = analyzeImportedConfig({
+						analysis,
+						moduleSpecifier: importBinding.moduleSpecifier,
+						exportName: importBinding.exportName,
+						allowCompilerTransform,
+						argumentsList: node.arguments
+					});
+					if (isLocalModuleSpecifier(importBinding.moduleSpecifier) || hasCompilerTransform !== null) return Boolean(hasCompilerTransform);
+				}
 			}
 			const topLevelBinding = getTopLevelBinding(analysis.sourceFile, node.expression.text);
 			if (topLevelBinding && ts.isFunctionLike(topLevelBinding) && analyzeConfigFunction(topLevelBinding, analysis, allowCompilerTransform, node.arguments)) return true;
@@ -62854,47 +63439,57 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 		return analyzeConfigNode(node.expression, analysis, allowCompilerTransform) || node.arguments.some((argument) => analyzeConfigNode(argument, analysis, false));
 	}
 	if (ts.isPropertyAccessExpression(node)) {
-		const requiredModuleSpecifier = getRequireModuleSpecifier(node.expression);
+		const requiredModuleSpecifier = getRequireModuleSpecifier$1(node.expression);
 		if (requiredModuleSpecifier) {
-			if (ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && (getScopedConfigBinding(node.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
-			if (requiredModuleSpecifier.startsWith(".")) {
-				const importedFilePath = resolveImportedConfigFile(analysis.filePath, requiredModuleSpecifier);
-				return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, node.name.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
-			}
+			if (ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && (analysis.localBindings.has(node.expression.expression.text) || getScopedConfigBinding(node.expression.expression).wasFound || hasTopLevelValueBinding(analysis.sourceFile, "require"))) return false;
+			if (analyzeImportedConfig({
+				analysis,
+				moduleSpecifier: requiredModuleSpecifier,
+				exportName: node.name.text,
+				allowCompilerTransform
+			})) return true;
 			return allowCompilerTransform && isCompilerTransformModule(requiredModuleSpecifier, node.name.text);
 		}
 		if (ts.isIdentifier(node.expression)) {
-			if (analysis.localBindings.has(node.expression.text)) {
-				const localInitializer = analysis.localBindings.get(node.expression.text);
-				return Boolean(localInitializer && analyzeConfigNode(localInitializer, analysis, allowCompilerTransform));
+			if (analysis.localBindings.has(node.expression.text) || getScopedConfigBinding(node.expression).wasFound) {
+				const selectedProperty = getSelectedObjectProperty(node.expression, node.name.text, analysis);
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform));
 			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
 				if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, node.name.text)) return true;
-				if (importBinding.moduleSpecifier.startsWith(".")) {
-					const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-					if (importedFilePath && analyzeConfigModuleExport(importedFilePath, node.name.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules)) return true;
-				}
+				if (analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: importBinding.moduleSpecifier,
+					exportName: node.name.text,
+					allowCompilerTransform
+				})) return true;
 				return false;
 			}
 			const selectedProperty = getSelectedObjectProperty(node.expression, node.name.text, analysis);
-			if (selectedProperty) return analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform);
+			if (selectedProperty) return analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform);
 			return false;
 		}
 		return analyzeConfigNode(node.expression, analysis, allowCompilerTransform);
 	}
 	if (ts.isElementAccessExpression(node) && node.argumentExpression && ts.isStringLiteralLike(node.argumentExpression)) {
 		if (ts.isIdentifier(node.expression)) {
+			if (analysis.localBindings.has(node.expression.text) || getScopedConfigBinding(node.expression).wasFound) {
+				const selectedProperty = getSelectedObjectProperty(node.expression, node.argumentExpression.text, analysis);
+				return Boolean(selectedProperty && analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform));
+			}
 			const importBinding = getImportBinding(analysis.sourceFile, node.expression.text);
 			if (importBinding?.isNamespace) {
 				if (allowCompilerTransform && isCompilerTransformModule(importBinding.moduleSpecifier, node.argumentExpression.text)) return true;
-				if (importBinding.moduleSpecifier.startsWith(".")) {
-					const importedFilePath = resolveImportedConfigFile(analysis.filePath, importBinding.moduleSpecifier);
-					return Boolean(importedFilePath && analyzeConfigModuleExport(importedFilePath, node.argumentExpression.text, allowCompilerTransform, analysis.importDepth + 1, analysis.visitedModules));
-				}
+				return Boolean(analyzeImportedConfig({
+					analysis,
+					moduleSpecifier: importBinding.moduleSpecifier,
+					exportName: node.argumentExpression.text,
+					allowCompilerTransform
+				}));
 			}
 			const selectedProperty = getSelectedObjectProperty(node.expression, node.argumentExpression.text, analysis);
-			if (selectedProperty) return analyzeConfigNode(selectedProperty, analysis, allowCompilerTransform);
+			if (selectedProperty) return analyzeConfigNode(selectedProperty.node, selectedProperty.analysis, allowCompilerTransform);
 			return false;
 		}
 		return analyzeConfigNode(node.expression, analysis, allowCompilerTransform);
@@ -62929,14 +63524,19 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 };
 const hasCompilerInConfigFile = (filePath) => analyzeConfigModuleExport(filePath, "default", false, 0, /* @__PURE__ */ new Set());
 const hasCompilerInConfigFiles = (directory, filenames) => filenames.some((filename) => hasCompilerInConfigFile(Path.join(directory, filename)));
-const hasCompilerInPackageJsonConfig = (packageJson) => isPlainObject(packageJson.babel) && analyzeConfigSourceFileExport(ts.parseJsonText("package.json", JSON.stringify(packageJson.babel)), "package.json#babel", "default", false, 0, /* @__PURE__ */ new Set());
-const hasCompilerConfiguration = (directory, packageJson) => hasCompilerInPackageJsonConfig(packageJson) || hasCompilerInConfigFiles(directory, REACT_COMPILER_CONFIG_FILENAMES);
+const hasCompilerInPackageJsonConfig = (directory, packageJson) => {
+	if (!isPlainObject(packageJson.babel)) return false;
+	const packageJsonPath = Path.join(directory, "package.json");
+	return analyzeConfigSourceFileExport(ts.parseJsonText(packageJsonPath, JSON.stringify(packageJson.babel)), packageJsonPath, "default", false, 0, /* @__PURE__ */ new Set());
+};
+const hasCompilerConfiguration = (directory, packageJson) => hasCompilerInPackageJsonConfig(directory, packageJson) || hasCompilerInConfigFiles(directory, REACT_COMPILER_CONFIG_FILENAMES);
 const hasCompilerConfigurationInAncestors = (directory) => {
 	if (isProjectBoundary(directory)) return false;
 	let ancestorDirectory = Path.dirname(directory);
 	while (ancestorDirectory !== Path.dirname(ancestorDirectory)) {
 		const ancestorPackagePath = Path.join(ancestorDirectory, "package.json");
-		if (hasCompilerInPackageJsonConfig(isFile(ancestorPackagePath) ? readPackageJson(ancestorPackagePath) : {}) || hasCompilerInConfigFiles(ancestorDirectory, BABEL_CONFIG_FILENAMES)) return true;
+		const ancestorPackageJson = isFile(ancestorPackagePath) ? readPackageJson(ancestorPackagePath) : {};
+		if (hasCompilerInPackageJsonConfig(ancestorDirectory, ancestorPackageJson) || hasCompilerInConfigFiles(ancestorDirectory, BABEL_CONFIG_FILENAMES)) return true;
 		if (isProjectBoundary(ancestorDirectory)) return false;
 		ancestorDirectory = Path.dirname(ancestorDirectory);
 	}
@@ -65262,6 +65862,7 @@ const classifyPackageRole = (filename) => {
 * Resolves the absolute path to read for a diagnostic's `filePath`,
 * accounting for the various shapes oxlint emits:
 *
+* - `file://` URL — decode to an absolute filesystem path.
 * - Absolute POSIX (`/abs/path/file.tsx`) — pass through.
 * - Absolute Windows (`C:/...` or `C:\...`) — pass through.
 * - `./relative` or bare relative — join against `rootDirectory`.
@@ -65271,6 +65872,7 @@ const classifyPackageRole = (filename) => {
 * use one canonical resolution path.
 */
 const resolveCandidateReadPath = (rootDirectory, filePath) => {
+	if (filePath.startsWith("file://")) return fileURLToPath(filePath);
 	const normalizedFile = filePath.replace(/\\/g, "/");
 	if (normalizedFile.startsWith("/") || /^[a-zA-Z]:\//.test(normalizedFile) || /^[a-zA-Z]:\\/.test(filePath)) return filePath;
 	return `${rootDirectory.replace(/\\/g, "/").replace(/\/$/, "")}/${normalizedFile.replace(/^\.\//, "")}`;
@@ -66165,7 +66767,7 @@ const warn = (message) => {
 	runSync(warn$1(message));
 };
 const CONFIG_BASENAME = "doctor.config";
-const CONFIG_EXTENSIONS = [
+const CONFIG_EXTENSIONS$1 = [
 	"ts",
 	"mts",
 	"cts",
@@ -66269,7 +66871,7 @@ const loadLegacyConfig = (directory) => {
 };
 const loadConfigFromDirectory = async (directory) => {
 	let sawBrokenConfigFile = false;
-	for (const extension of CONFIG_EXTENSIONS) {
+	for (const extension of CONFIG_EXTENSIONS$1) {
 		const filePath = Path.join(directory, `${CONFIG_BASENAME}.${extension}`);
 		if (!isFile(filePath)) continue;
 		const isDataFile = DATA_CONFIG_EXTENSIONS.has(extension);
@@ -66956,6 +67558,316 @@ const buildReactNativeDiagnostic = (input) => ({
 	column: input.column ?? 0,
 	category: input.category ?? "Correctness"
 });
+const ANDROID_APP_BUILD_FILE_NAMES = ["build.gradle", "build.gradle.kts"];
+const BUILD_TYPES_BLOCK_PATTERN = /\bbuildTypes\s*\{/g;
+const RELEASE_STRING_MARKER = "__RD_RELEASE__";
+const RELEASE_BLOCK_PATTERNS = [/\brelease\s*\{/g, /\b(?:getByName|named)\s*\(\s*(?:["']release["']|__RD_RELEASE__)\s*\)\s*\{/g];
+const MINIFY_ASSIGNMENT_PATTERN = /\b(?:isMinifyEnabled|minifyEnabled)\b\s*(?:\(\s*|=\s*|\s+)([^;}\r\n]+)/g;
+const SHRINK_RESOURCES_ASSIGNMENT_PATTERN = /\b(?:isShrinkResources|shrinkResources)\b\s*(?:\(\s*|=\s*|\s+)([^;}\r\n]+)/g;
+const stripGradleComments = (contents) => {
+	let result = "";
+	let index = 0;
+	let quote = null;
+	while (index < contents.length) {
+		const character = contents[index];
+		const nextCharacter = contents[index + 1];
+		if (quote !== null) {
+			result += character;
+			if (character === "\\") {
+				result += nextCharacter ?? "";
+				index += 2;
+				continue;
+			}
+			if (character === quote) quote = null;
+			index += 1;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			result += character;
+			index += 1;
+			continue;
+		}
+		if (character === "/" && nextCharacter === "/") {
+			while (index < contents.length && contents[index] !== "\n") {
+				result += " ";
+				index += 1;
+			}
+			continue;
+		}
+		if (character === "/" && nextCharacter === "*") {
+			result += "  ";
+			index += 2;
+			while (index < contents.length && !(contents[index] === "*" && contents[index + 1] === "/")) {
+				result += contents[index] === "\n" ? "\n" : " ";
+				index += 1;
+			}
+			if (index < contents.length) {
+				result += "  ";
+				index += 2;
+			}
+			continue;
+		}
+		result += character;
+		index += 1;
+	}
+	return result;
+};
+const maskGradleStrings = (contents) => {
+	let result = "";
+	let index = 0;
+	let quote = null;
+	while (index < contents.length) {
+		const character = contents[index];
+		if (quote === null) {
+			if (character === "\"" || character === "'") {
+				quote = character;
+				result += " ";
+			} else result += character;
+			index += 1;
+			continue;
+		}
+		if (character === "\\") {
+			result += "  ";
+			index += 2;
+			continue;
+		}
+		if (character === quote) quote = null;
+		result += character === "\n" ? "\n" : " ";
+		index += 1;
+	}
+	return result;
+};
+const findBlockContents = (contents, pattern) => {
+	const blocks = [];
+	pattern.lastIndex = 0;
+	let match = pattern.exec(contents);
+	while (match !== null) {
+		const openingBraceIndex = pattern.lastIndex - 1;
+		let depth = 1;
+		let index = openingBraceIndex + 1;
+		let quote = null;
+		while (index < contents.length && depth > 0) {
+			const character = contents[index];
+			if (quote !== null) {
+				if (character === "\\") {
+					index += 2;
+					continue;
+				}
+				if (character === quote) quote = null;
+			} else if (character === "\"" || character === "'") quote = character;
+			else if (character === "{") depth += 1;
+			else if (character === "}") depth -= 1;
+			index += 1;
+		}
+		if (depth === 0) blocks.push(contents.slice(openingBraceIndex + 1, index - 1));
+		match = pattern.exec(contents);
+	}
+	return blocks;
+};
+const getFinalStaticBoolean = (contents, pattern) => {
+	pattern.lastIndex = 0;
+	let finalValue = null;
+	let match = pattern.exec(contents);
+	while (match !== null) {
+		const staticValue = match[1]?.trim().replace(/\)$/, "").trim();
+		if (staticValue === "true") finalValue = true;
+		else if (staticValue === "false") finalValue = false;
+		else finalValue = null;
+		match = pattern.exec(contents);
+	}
+	return finalValue;
+};
+const getReleaseBlocks = (contents) => findBlockContents(contents, BUILD_TYPES_BLOCK_PATTERN).flatMap((buildTypesBlock) => RELEASE_BLOCK_PATTERNS.flatMap((pattern) => findBlockContents(buildTypesBlock, pattern)));
+const readAndroidReleaseShrinking = (rootDirectory) => {
+	for (const buildFileName of ANDROID_APP_BUILD_FILE_NAMES) {
+		const filePath = Path.posix.join("android", "app", buildFileName);
+		const absoluteFilePath = Path.join(rootDirectory, filePath);
+		if (!isFile(absoluteFilePath)) continue;
+		let contents;
+		try {
+			contents = stripGradleComments(NFS.readFileSync(absoluteFilePath, "utf-8"));
+		} catch {
+			return null;
+		}
+		const releaseBlocks = getReleaseBlocks(maskGradleStrings(contents.replace(/(["'])release\1/g, RELEASE_STRING_MARKER)));
+		const [releaseBlock] = releaseBlocks;
+		if (releaseBlock === void 0 || releaseBlocks.length !== 1) return null;
+		const hasDisabledMinification = getFinalStaticBoolean(releaseBlock, MINIFY_ASSIGNMENT_PATTERN) === false;
+		const hasDisabledResourceShrinking = getFinalStaticBoolean(releaseBlock, SHRINK_RESOURCES_ASSIGNMENT_PATTERN) === false;
+		if (!hasDisabledMinification && !hasDisabledResourceShrinking) return null;
+		return {
+			filePath,
+			hasDisabledMinification,
+			hasDisabledResourceShrinking
+		};
+	}
+	return null;
+};
+const checkReactNativeAndroidReleaseShrinking = (rootDirectory) => {
+	const releaseShrinking = readAndroidReleaseShrinking(rootDirectory);
+	if (releaseShrinking === null) return [];
+	const disabledFeatures = [releaseShrinking.hasDisabledMinification ? "code minification" : null, releaseShrinking.hasDisabledResourceShrinking ? "resource shrinking" : null].filter((feature) => feature !== null);
+	return [buildReactNativeDiagnostic({
+		filePath: releaseShrinking.filePath,
+		rule: "rn-android-release-shrinking-disabled",
+		category: "Performance",
+		message: `The Android release build explicitly disables ${disabledFeatures.join(" and ")}, leaving unreachable code or resources in the shipped app.`,
+		help: "Enable release code minification and resource shrinking, then test the optimized build and add keep rules for libraries that require them."
+	})];
+};
+const getTypescriptScriptKind = (fileName) => {
+	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (fileName.endsWith(".ts")) return ts.ScriptKind.TS;
+	return ts.ScriptKind.JS;
+};
+const BABEL_CONFIG_FILE_NAMES$1 = [
+	"babel.config.js",
+	"babel.config.cjs",
+	"babel.config.mjs",
+	"babel.config.ts",
+	"babel.config.cts",
+	"babel.config.json",
+	".babelrc",
+	".babelrc.js",
+	".babelrc.cjs",
+	".babelrc.mjs",
+	".babelrc.cts",
+	".babelrc.json"
+];
+const readUnknownPluginNames = (value) => {
+	if (!Array.isArray(value)) return null;
+	const pluginNames = [];
+	for (const entry of value) {
+		if (typeof entry === "string") {
+			pluginNames.push(entry);
+			continue;
+		}
+		if (Array.isArray(entry) && typeof entry[0] === "string") {
+			pluginNames.push(entry[0]);
+			continue;
+		}
+		return null;
+	}
+	return pluginNames;
+};
+const getStaticPropertyName$1 = (propertyName) => {
+	if (ts.isIdentifier(propertyName) || ts.isStringLiteralLike(propertyName)) return propertyName.text;
+	return null;
+};
+const getStaticPluginName = (expression) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (ts.isStringLiteralLike(unwrappedExpression)) return unwrappedExpression.text;
+	if (!ts.isArrayLiteralExpression(unwrappedExpression)) return null;
+	const pluginExpression = unwrappedExpression.elements[0];
+	return pluginExpression && ts.isStringLiteralLike(pluginExpression) ? pluginExpression.text : null;
+};
+const getPluginNamesFromObject = (objectExpression) => {
+	if (objectExpression.properties.some((property) => ts.isSpreadAssignment(property))) return null;
+	const pluginProperties = objectExpression.properties.filter((property) => ts.isPropertyAssignment(property) && getStaticPropertyName$1(property.name) === "plugins");
+	if (pluginProperties.length !== 1) return pluginProperties.length === 0 ? [] : null;
+	const pluginListExpression = unwrapTypescriptExpression(pluginProperties[0].initializer);
+	if (!ts.isArrayLiteralExpression(pluginListExpression)) return null;
+	const pluginNames = [];
+	for (const element of pluginListExpression.elements) {
+		if (ts.isSpreadElement(element)) return null;
+		const pluginName = getStaticPluginName(element);
+		if (pluginName === null) return null;
+		pluginNames.push(pluginName);
+	}
+	return pluginNames;
+};
+const isModuleExports = (expression) => ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "module" && expression.name.text === "exports" || ts.isElementAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "module" && expression.argumentExpression !== void 0 && ts.isStringLiteralLike(expression.argumentExpression) && expression.argumentExpression.text === "exports";
+const getDirectExportedObject = (sourceFile) => {
+	const exportedExpressions = [];
+	for (const statement of sourceFile.statements) {
+		if (ts.isExportAssignment(statement)) {
+			exportedExpressions.push(statement.expression);
+			continue;
+		}
+		if (ts.isExpressionStatement(statement) && ts.isBinaryExpression(statement.expression) && statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && isModuleExports(statement.expression.left)) exportedExpressions.push(statement.expression.right);
+	}
+	if (exportedExpressions.length !== 1) return null;
+	const exportedExpression = unwrapTypescriptExpression(exportedExpressions[0]);
+	return ts.isObjectLiteralExpression(exportedExpression) ? exportedExpression : null;
+};
+const parseConfigPluginNames = (filePath, contents) => {
+	try {
+		const parsedJson = JSON.parse(contents);
+		return isPlainObject(parsedJson) ? readUnknownPluginNames(parsedJson.plugins) : null;
+	} catch {
+		if (ts.transpileModule(contents, {
+			fileName: filePath,
+			reportDiagnostics: true,
+			compilerOptions: { allowJs: true }
+		}).diagnostics?.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) return null;
+		const exportedObject = getDirectExportedObject(ts.createSourceFile(filePath, contents, ts.ScriptTarget.Latest, true, getTypescriptScriptKind(filePath)));
+		return exportedObject === null ? null : getPluginNamesFromObject(exportedObject);
+	}
+};
+const readStaticBabelPluginNames = (rootDirectory) => {
+	for (const fileName of BABEL_CONFIG_FILE_NAMES$1) {
+		const absoluteFilePath = Path.join(rootDirectory, fileName);
+		if (!isFile(absoluteFilePath)) continue;
+		try {
+			return {
+				filePath: fileName,
+				pluginNames: parseConfigPluginNames(fileName, NFS.readFileSync(absoluteFilePath, "utf-8"))
+			};
+		} catch {
+			return {
+				filePath: fileName,
+				pluginNames: null
+			};
+		}
+	}
+	const packageJson = readPackageJson(Path.join(rootDirectory, "package.json"));
+	if (!isPlainObject(packageJson.babel)) return null;
+	return {
+		filePath: "package.json",
+		pluginNames: readUnknownPluginNames(packageJson.babel.plugins)
+	};
+};
+const REACT_COMPILER_PLUGIN_NAMES = new Set(["babel-plugin-react-compiler", "react-compiler"]);
+const REANIMATED_PLUGIN_NAME = "react-native-reanimated/plugin";
+const WORKLETS_PLUGIN_NAME = "react-native-worklets/plugin";
+const checkReactCompilerPluginOrder = (filePath, pluginNames) => {
+	if (pluginNames.findIndex((pluginName) => REACT_COMPILER_PLUGIN_NAMES.has(pluginName)) <= 0) return [];
+	return [buildReactNativeDiagnostic({
+		filePath,
+		rule: "rn-react-compiler-plugin-first",
+		category: "Performance",
+		message: "The React Compiler Babel plugin is not first, so an earlier transform can change component or hook code before the compiler analyzes it.",
+		help: "Move `babel-plugin-react-compiler` to the first entry in the Babel `plugins` array."
+	})];
+};
+const checkReanimatedPluginOrder = (project, filePath, pluginNames) => {
+	const reanimatedMajorVersion = project.reanimatedVersion === null || project.reanimatedVersion === void 0 ? null : getLowestDependencyMajor(project.reanimatedVersion);
+	if (reanimatedMajorVersion === null || reanimatedMajorVersion < 4) return [];
+	const diagnostics = [];
+	if (pluginNames.includes(REANIMATED_PLUGIN_NAME)) diagnostics.push(buildReactNativeDiagnostic({
+		filePath,
+		rule: "rn-reanimated-worklets-plugin-last",
+		category: "Performance",
+		message: "This Reanimated 4 project still uses `react-native-reanimated/plugin`, which was renamed to the Worklets Babel plugin.",
+		help: "Replace it with `react-native-worklets/plugin` and keep that plugin last in the Babel `plugins` array."
+	}));
+	const workletsPluginIndex = pluginNames.lastIndexOf(WORKLETS_PLUGIN_NAME);
+	if (workletsPluginIndex !== -1 && workletsPluginIndex !== pluginNames.length - 1) diagnostics.push(buildReactNativeDiagnostic({
+		filePath,
+		rule: "rn-reanimated-worklets-plugin-last",
+		category: "Performance",
+		message: "`react-native-worklets/plugin` is not last in the Babel `plugins` array, so later transforms can prevent worklets from being compiled correctly.",
+		help: "Move `react-native-worklets/plugin` to the final entry in the Babel `plugins` array."
+	}));
+	return diagnostics;
+};
+const checkReactNativeBabelPluginOrder = (rootDirectory, project) => {
+	const babelPlugins = readStaticBabelPluginNames(rootDirectory);
+	if (babelPlugins === null || babelPlugins.pluginNames === null) return [];
+	return [...checkReactCompilerPluginOrder(babelPlugins.filePath, babelPlugins.pluginNames), ...checkReanimatedPluginOrder(project, babelPlugins.filePath, babelPlugins.pluginNames)];
+};
 const BUILDER_BOB_PACKAGE = "react-native-builder-bob";
 const isBuilderBobLibrary = (packageJson) => {
 	const bobConfig = packageJson[BUILDER_BOB_PACKAGE];
@@ -67032,7 +67944,12 @@ const checkReactNativeMetroBabelPreset = (rootDirectory) => {
 const isReactNativeProject = (project) => project.framework === "react-native" || project.framework === "expo" || project.hasReactNativeWorkspace || project.expoVersion !== null;
 const checkReactNativeProject = (rootDirectory, project) => {
 	if (!isReactNativeProject(project)) return [];
-	return [...checkReactNativeMetroBabelPreset(rootDirectory), ...checkReactNativeLibraryDependencies(rootDirectory)];
+	return [
+		...checkReactNativeMetroBabelPreset(rootDirectory),
+		...checkReactNativeBabelPluginOrder(rootDirectory, project),
+		...checkReactNativeAndroidReleaseShrinking(rootDirectory),
+		...checkReactNativeLibraryDependencies(rootDirectory)
+	];
 };
 const RULE_KEY = "no-vulnerable-react-server-components";
 const REACT_RSC_ADVISORIES_BY_MINOR = {
@@ -67183,17 +68100,6 @@ const checkReactServerComponentsAdvisory = (scanDirectory, project) => {
 	}
 	return diagnostics;
 };
-const getTypescriptScriptKind = (fileName) => {
-	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (fileName.endsWith(".ts")) return ts.ScriptKind.TS;
-	return ts.ScriptKind.JS;
-};
-const unwrapTypescriptExpression = (expression) => {
-	let currentExpression = expression;
-	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
-	return currentExpression;
-};
 const EMPTY_MOTION_EXPRESSION_EVIDENCE = {
 	isAnimationFunction: false,
 	isMotionComponent: false,
@@ -67749,7 +68655,11 @@ const buildCapabilities = (project) => {
 	capabilities.add(project.framework);
 	if (project.reactVersion !== null || project.preactVersion !== null) capabilities.add("react");
 	if (project.framework === "expo" || project.framework === "react-native" || project.hasReactNativeWorkspace) capabilities.add("react-native");
-	if (project.expoVersion !== null) capabilities.add("expo");
+	if (project.expoVersion !== null) {
+		capabilities.add("expo");
+		const expoSdkMajorVersion = getLowestDependencyMajor(project.expoVersion);
+		if (expoSdkMajorVersion !== null && expoSdkMajorVersion >= 54) capabilities.add("expo:54");
+	}
 	if ((project.framework === "nextjs" || project.framework === "tanstack-start" || project.framework === "remix") && !project.isStaticExport) capabilities.add("server-actions");
 	if (SSR_FRAMEWORKS.has(project.framework) || project.hasSsrDependency) capabilities.add("ssr");
 	if (CLIENT_ONLY_FRAMEWORKS.has(project.framework)) capabilities.add("client-only");
@@ -67813,6 +68723,11 @@ const buildCapabilities = (project) => {
 	if (project.zustandMajorVersion !== void 0 && project.zustandMajorVersion !== null && project.zustandMajorVersion >= 1 && project.zustandMajorVersion <= 5) addVersionCapabilityLadder(capabilities, "zustand", project.zustandMajorVersion, 1, 5);
 	if (project.isPreES2023Target) capabilities.add("pre-es2023");
 	if (project.hasReactCompiler) capabilities.add("react-compiler");
+	if (project.reanimatedVersion !== void 0 && project.reanimatedVersion !== null) {
+		capabilities.add("reanimated");
+		const reanimatedMajorVersion = getLowestDependencyMajor(project.reanimatedVersion);
+		if (reanimatedMajorVersion !== null && reanimatedMajorVersion >= 4) capabilities.add("reanimated:4");
+	}
 	if (Boolean(project.hasTanStackQuery) || Boolean(project.tanstackQueryVersion)) capabilities.add("tanstack-query");
 	if (project.styledComponentsVersion) {
 		capabilities.add("styled-components");
@@ -69152,7 +70067,10 @@ var Git = class Git extends Service()("react-doctor/Git") {
 				if (argvLengthChars > spawnArgsLengthCap) return yield* foldSpawnFailure(`spawn ENAMETOOLONG (${argvLengthChars} argv chars exceed ${spawnArgsLengthCap})`);
 				const handle = yield* spawner.spawn(make$1(input.command, [...input.args], {
 					cwd: input.directory,
-					env: input.env,
+					env: input.command === "git" ? {
+						...input.env,
+						GIT_DIR: void 0
+					} : input.env,
 					extendEnv: true
 				}));
 				const maxStdoutBytes = input.maxStdoutBytes;
@@ -69425,7 +70343,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 				"--diff-filter=ACMR",
 				"--relative"
 			]).pipe(map$3((result) => {
-				if (result.status !== 0) return [];
+				if (result.status !== 0) return null;
 				return splitNullSeparated(result.stdout);
 			})),
 			showStagedContent: (directory, relativePath, options) => runCommand({
@@ -69710,7 +70628,11 @@ const neutralizeDisableDirectives = async (rootDirectory, includePaths) => {
 const ROOT_DIRECTORY_PLACEHOLDER = "<root>";
 const normalizeConfigForHash = (config) => {
 	const clone = JSON.parse(JSON.stringify(config));
-	if (clone?.settings?.["react-doctor"]) clone.settings["react-doctor"].rootDirectory = ROOT_DIRECTORY_PLACEHOLDER;
+	if (clone?.settings?.["react-doctor"]) {
+		const reactDoctorSettings = clone.settings["react-doctor"];
+		reactDoctorSettings.rootDirectory = ROOT_DIRECTORY_PLACEHOLDER;
+		if (Array.isArray(reactDoctorSettings.unpluginAutoImportRootDirectories)) reactDoctorSettings.unpluginAutoImportRootDirectories = [ROOT_DIRECTORY_PLACEHOLDER];
+	}
 	if (Array.isArray(clone?.jsPlugins)) clone.jsPlugins = clone.jsPlugins.map((_, index) => `<plugin:${index}>`);
 	return clone;
 };
@@ -69869,13 +70791,14 @@ const buildUserPluginRules = (userPlugin, severityControls) => {
 	}
 	return enabled;
 };
-const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, extendsPaths = [], ignoredTags = /* @__PURE__ */ new Set(), includedTags = /* @__PURE__ */ new Set(), includeTagDefaults = false, serverAuthFunctionNames, severityControls, userPlugins = [], disableReactHooksJsPlugin = false, ruleSelection, sidecarRuleIdFilter }) => {
+const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, extendsPaths = [], ignoredTags = /* @__PURE__ */ new Set(), includedTags = /* @__PURE__ */ new Set(), includeTagDefaults = false, runtimeGlobals, unpluginAutoImportGlobalScopes, serverAuthFunctionNames, severityControls, userPlugins = [], disableReactHooksJsPlugin = false, ruleSelection, sidecarRuleIdFilter }) => {
 	const hasIncludedTags = includedTags.size > 0;
 	const reactHooksJsPlugin = disableReactHooksJsPlugin || ruleSelection === "sidecar" || hasIncludedTags ? null : resolveReactHooksJsPlugin(project.hasReactCompiler || project.hasReactCompilerLintPlugin === true, customRulesOnly);
 	const reactCompilerRules = reactHooksJsPlugin ? applyRuleSeverityControls(filterRulesToAvailable(REACT_COMPILER_RULES, "react-hooks-js", reactHooksJsPlugin.availableRuleNames), severityControls) : {};
 	const jsPlugins = [];
 	if (reactHooksJsPlugin) jsPlugins.push(reactHooksJsPlugin.entry);
 	const capabilities = getCapabilities(project);
+	const settingsRootDirectory = resolveSettingsRootDirectory(project.rootDirectory);
 	const enabledReactDoctorRules = {};
 	for (const registryEntry of REACT_DOCTOR_RULES) {
 		const rule = reactDoctorPlugin.rules[registryEntry.id];
@@ -69921,8 +70844,16 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		jsPlugins: [...jsPlugins, pluginPath],
 		settings: { "react-doctor": {
 			framework: project.framework,
-			rootDirectory: resolveSettingsRootDirectory(project.rootDirectory),
+			rootDirectory: settingsRootDirectory,
 			capabilities: [...capabilities].sort(),
+			...runtimeGlobals && runtimeGlobals.length > 0 ? { runtimeGlobals: [...runtimeGlobals] } : {},
+			...unpluginAutoImportGlobalScopes && unpluginAutoImportGlobalScopes.length > 0 ? {
+				unpluginAutoImportRootDirectories: [...new Set([settingsRootDirectory, project.rootDirectory])],
+				unpluginAutoImportGlobalScopes: unpluginAutoImportGlobalScopes.map((scope) => ({
+					directory: scope.directory,
+					names: [...scope.names]
+				}))
+			} : {},
 			...project.shopifyFlashListMajorVersion !== null ? { shopifyFlashListMajorVersion: project.shopifyFlashListMajorVersion } : {},
 			...serverAuthFunctionNames && serverAuthFunctionNames.length > 0 ? { serverAuthFunctionNames: [...serverAuthFunctionNames] } : {}
 		} },
@@ -69933,6 +70864,245 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		}
 	};
 };
+const AUTO_IMPORT_ADAPTER_PATTERN = /^unplugin-auto-import\/(?:astro|esbuild|rollup|rolldown|rspack|vite|webpack)$/;
+const CONFIG_BASENAMES = [
+	"astro.config",
+	"esbuild.config",
+	"rollup.config",
+	"rolldown.config",
+	"rspack.config",
+	"vite.config",
+	"webpack.config"
+];
+const CONFIG_EXTENSIONS = [
+	".cjs",
+	".cts",
+	".js",
+	".mjs",
+	".mts",
+	".ts"
+];
+const CONFIG_FILENAMES = new Set(CONFIG_BASENAMES.flatMap((basename) => CONFIG_EXTENSIONS.map((extension) => `${basename}${extension}`)));
+const DEFAULT_ESLINT_GLOBALS_PATH = ".eslintrc-auto-import.json";
+const SUPPORTED_GLOBAL_VALUES = new Set([
+	true,
+	false,
+	"readable",
+	"readonly",
+	"writable",
+	"writeable"
+]);
+const getStaticProperty = (objectExpression, propertyName) => objectExpression.properties.find((property) => {
+	if (ts.isSpreadAssignment(property)) return false;
+	const name = ts.isComputedPropertyName(property.name) ? unwrapTypescriptExpression(property.name.expression) : property.name;
+	return (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) && name.text === propertyName;
+}) ?? null;
+const hasNonLiteralComputedProperty = (objectExpression) => objectExpression.properties.some((property) => !ts.isSpreadAssignment(property) && ts.isComputedPropertyName(property.name) && !ts.isStringLiteralLike(unwrapTypescriptExpression(property.name.expression)));
+const getStaticPropertyAssignment = (objectExpression, propertyName) => {
+	const property = getStaticProperty(objectExpression, propertyName);
+	return property && ts.isPropertyAssignment(property) ? property : null;
+};
+const getRequireModuleSpecifier = (expression) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "default") return getRequireModuleSpecifier(unwrappedExpression.expression);
+	if (!ts.isCallExpression(unwrappedExpression) || !ts.isIdentifier(unwrappedExpression.expression) || unwrappedExpression.expression.text !== "require" || unwrappedExpression.arguments.length !== 1) return null;
+	const moduleSpecifier = unwrappedExpression.arguments[0];
+	return moduleSpecifier && ts.isStringLiteralLike(moduleSpecifier) ? moduleSpecifier.text : null;
+};
+const getRequiredPropertyModuleSpecifier = (expression, propertyName) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	return ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === propertyName ? getRequireModuleSpecifier(unwrappedExpression.expression) : null;
+};
+const isCommonJsExportAssignment = (node, sourceFile) => ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && (node.left.getText(sourceFile) === "module.exports" || node.left.getText(sourceFile) === "exports.default");
+const isTopLevelExpression = (node) => {
+	let ancestor = node.parent;
+	while (ancestor && !ts.isSourceFile(ancestor)) {
+		if (ts.isExpressionStatement(ancestor)) return ts.isSourceFile(ancestor.parent);
+		if (!ts.isParenthesizedExpression(ancestor) && !ts.isAsExpression(ancestor) && !ts.isSatisfiesExpression(ancestor) && !ts.isNonNullExpression(ancestor) && !ts.isTypeAssertionExpression(ancestor) && !ts.isAwaitExpression(ancestor)) return false;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isInsideActiveConfigProperty = (node, propertyName, sourceFile, esbuildBindings, esbuildNamespaceBindings) => {
+	let ancestor = node.parent;
+	let didFindConfigProperty = false;
+	while (ancestor && !ts.isSourceFile(ancestor)) {
+		if (!didFindConfigProperty && !ts.isArrayLiteralExpression(ancestor) && !ts.isParenthesizedExpression(ancestor) && !ts.isAsExpression(ancestor) && !ts.isSatisfiesExpression(ancestor) && !ts.isNonNullExpression(ancestor) && !ts.isTypeAssertionExpression(ancestor) && !ts.isPropertyAssignment(ancestor)) return false;
+		if (ts.isPropertyAssignment(ancestor)) {
+			const isConfigProperty = (ts.isIdentifier(ancestor.name) || ts.isStringLiteralLike(ancestor.name)) && ancestor.name.text === propertyName;
+			if (didFindConfigProperty || !isConfigProperty) return false;
+			if (!ts.isObjectLiteralExpression(ancestor.parent) || ancestor.parent.properties.some(ts.isSpreadAssignment)) return false;
+			didFindConfigProperty = true;
+			ancestor = ancestor.parent;
+			continue;
+		}
+		if (didFindConfigProperty) {
+			if (ts.isExportAssignment(ancestor)) return true;
+			if (isCommonJsExportAssignment(ancestor, sourceFile)) return isTopLevelExpression(ancestor);
+			if (propertyName === "plugins" && ts.isCallExpression(ancestor) && (ts.isIdentifier(ancestor.expression) ? esbuildBindings.has(ancestor.expression.text) : ts.isPropertyAccessExpression(ancestor.expression) && ancestor.expression.name.text === "build" && (ts.isIdentifier(ancestor.expression.expression) && esbuildNamespaceBindings.has(ancestor.expression.expression.text) || getRequireModuleSpecifier(ancestor.expression.expression) === "esbuild"))) return isTopLevelExpression(ancestor);
+			if (!(ts.isObjectLiteralExpression(ancestor) || ts.isParenthesizedExpression(ancestor) || ts.isAsExpression(ancestor) || ts.isSatisfiesExpression(ancestor) || ts.isNonNullExpression(ancestor) || ts.isTypeAssertionExpression(ancestor) || ts.isCallExpression(ancestor) && ts.isIdentifier(ancestor.expression) && ancestor.expression.text === "defineConfig")) return false;
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const getGlobalsPathFromActiveAutoImportCall = (callExpression, packageDirectory) => {
+	const optionsExpression = callExpression.arguments[0];
+	if (!optionsExpression) return null;
+	const unwrappedOptions = unwrapTypescriptExpression(optionsExpression);
+	if (!ts.isObjectLiteralExpression(unwrappedOptions)) return null;
+	if (unwrappedOptions.properties.some(ts.isSpreadAssignment) || hasNonLiteralComputedProperty(unwrappedOptions)) return null;
+	if (getStaticProperty(unwrappedOptions, "include") || getStaticProperty(unwrappedOptions, "exclude")) return null;
+	const eslintrcProperty = getStaticPropertyAssignment(unwrappedOptions, "eslintrc");
+	if (!eslintrcProperty) return null;
+	const eslintrcExpression = unwrapTypescriptExpression(eslintrcProperty.initializer);
+	if (!ts.isObjectLiteralExpression(eslintrcExpression)) return null;
+	if (eslintrcExpression.properties.some(ts.isSpreadAssignment) || hasNonLiteralComputedProperty(eslintrcExpression)) return null;
+	const enabledProperty = getStaticPropertyAssignment(eslintrcExpression, "enabled");
+	if (!enabledProperty || unwrapTypescriptExpression(enabledProperty.initializer).kind !== ts.SyntaxKind.TrueKeyword) return null;
+	const filepathProperty = getStaticProperty(eslintrcExpression, "filepath");
+	if (!filepathProperty) return Path.join(packageDirectory, DEFAULT_ESLINT_GLOBALS_PATH);
+	if (!ts.isPropertyAssignment(filepathProperty)) return null;
+	const filepathExpression = unwrapTypescriptExpression(filepathProperty.initializer);
+	return ts.isStringLiteralLike(filepathExpression) ? Path.resolve(packageDirectory, filepathExpression.text) : null;
+};
+const collectGlobalsPathsFromConfig = (configPath, packageDirectory) => {
+	let sourceText;
+	try {
+		sourceText = NFS.readFileSync(configPath, "utf8");
+	} catch {
+		return {
+			didFindActiveAutoImport: false,
+			globalsPaths: []
+		};
+	}
+	const sourceFile = ts.createSourceFile(configPath, sourceText, ts.ScriptTarget.Latest, true);
+	const autoImportBindings = /* @__PURE__ */ new Map();
+	const esbuildBindings = /* @__PURE__ */ new Set();
+	const esbuildNamespaceBindings = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (ts.isImportDeclaration(statement) && ts.isStringLiteralLike(statement.moduleSpecifier)) {
+			const moduleSpecifier = statement.moduleSpecifier.text;
+			if (AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) {
+				const defaultBinding = statement.importClause?.name;
+				if (defaultBinding) autoImportBindings.set(defaultBinding.text, moduleSpecifier);
+			}
+			if (moduleSpecifier === "esbuild") {
+				const defaultBinding = statement.importClause?.name;
+				if (defaultBinding) esbuildNamespaceBindings.add(defaultBinding.text);
+				const namedBindings = statement.importClause?.namedBindings;
+				if (namedBindings && ts.isNamedImports(namedBindings)) {
+					for (const importSpecifier of namedBindings.elements) if ((importSpecifier.propertyName ?? importSpecifier.name).text === "build") esbuildBindings.add(importSpecifier.name.text);
+				}
+				if (namedBindings && ts.isNamespaceImport(namedBindings)) esbuildNamespaceBindings.add(namedBindings.name.text);
+			}
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			if (!declaration.initializer) continue;
+			const declarationName = ts.isIdentifier(declaration.name) ? declaration.name.text : null;
+			const moduleSpecifier = getRequireModuleSpecifier(declaration.initializer);
+			if (declarationName && moduleSpecifier && AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) autoImportBindings.set(declarationName, moduleSpecifier);
+			if (moduleSpecifier === "esbuild") {
+				if (declarationName) esbuildNamespaceBindings.add(declarationName);
+				if (ts.isObjectBindingPattern(declaration.name)) for (const bindingElement of declaration.name.elements) {
+					const importedName = bindingElement.propertyName ?? bindingElement.name;
+					if (ts.isIdentifier(importedName) && importedName.text === "build" && ts.isIdentifier(bindingElement.name)) esbuildBindings.add(bindingElement.name.text);
+				}
+			}
+			if (declarationName && getRequiredPropertyModuleSpecifier(declaration.initializer, "build") === "esbuild") esbuildBindings.add(declarationName);
+		}
+	}
+	const globalsPaths = /* @__PURE__ */ new Set();
+	let didFindActiveAutoImport = false;
+	let didFindUnsafeActiveAutoImport = false;
+	const visit = (node) => {
+		if (ts.isCallExpression(node)) {
+			const moduleSpecifier = ts.isIdentifier(node.expression) ? autoImportBindings.get(node.expression.text) : getRequireModuleSpecifier(node.expression);
+			if (moduleSpecifier && AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) {
+				if (isInsideActiveConfigProperty(node, moduleSpecifier.endsWith("/astro") ? "integrations" : "plugins", sourceFile, esbuildBindings, esbuildNamespaceBindings)) {
+					didFindActiveAutoImport = true;
+					const globalsPath = getGlobalsPathFromActiveAutoImportCall(node, packageDirectory);
+					if (globalsPath) globalsPaths.add(globalsPath);
+					else didFindUnsafeActiveAutoImport = true;
+				}
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return {
+		didFindActiveAutoImport,
+		globalsPaths: didFindUnsafeActiveAutoImport ? [] : [...globalsPaths]
+	};
+};
+const collectGeneratedGlobalNames = (globalsPath, rootDirectory) => {
+	const relativePath = Path.relative(rootDirectory, globalsPath);
+	if (relativePath.startsWith("..") || Path.isAbsolute(relativePath)) return [];
+	const parsed = failOpenReadJson(globalsPath, null);
+	if (!isPlainObject(parsed) || !isPlainObject(parsed.globals)) return [];
+	return Object.entries(parsed.globals).filter((entry) => entry[0].length > 0 && (typeof entry[1] === "boolean" || typeof entry[1] === "string") && SUPPORTED_GLOBAL_VALUES.has(entry[1])).map(([name]) => name).sort();
+};
+const findOwningPackageDirectory = (absoluteFilePath, rootDirectory, cache) => {
+	let currentDirectory = Path.dirname(absoluteFilePath);
+	const visitedDirectories = [];
+	while (true) {
+		const cachedDirectory = cache.get(currentDirectory);
+		if (cachedDirectory !== void 0) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, cachedDirectory);
+			return cachedDirectory;
+		}
+		const relativeDirectory = Path.relative(rootDirectory, currentDirectory);
+		if (relativeDirectory.startsWith("..") || Path.isAbsolute(relativeDirectory)) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, null);
+			return null;
+		}
+		visitedDirectories.push(currentDirectory);
+		if (NFS.existsSync(Path.join(currentDirectory, "package.json"))) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, currentDirectory);
+			return currentDirectory;
+		}
+		if (currentDirectory === rootDirectory) {
+			for (const visitedDirectory of visitedDirectories) cache.set(visitedDirectory, null);
+			return null;
+		}
+		currentDirectory = Path.dirname(currentDirectory);
+	}
+};
+const collectPackageGlobalNames = (packageDirectory, rootDirectory) => {
+	let directoryEntries;
+	try {
+		directoryEntries = NFS.readdirSync(packageDirectory, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const configuredGlobalsPaths = [];
+	for (const entry of directoryEntries) {
+		if (!entry.isFile() && !entry.isSymbolicLink() || !CONFIG_FILENAMES.has(entry.name)) continue;
+		const configGlobalsPaths = collectGlobalsPathsFromConfig(Path.join(packageDirectory, entry.name), packageDirectory);
+		if (configGlobalsPaths.didFindActiveAutoImport) configuredGlobalsPaths.push(configGlobalsPaths.globalsPaths.toSorted());
+	}
+	if (configuredGlobalsPaths.length === 0) return [];
+	const globalsPaths = configuredGlobalsPaths[0];
+	if (configuredGlobalsPaths.some((candidatePaths) => candidatePaths.length !== globalsPaths.length || candidatePaths.some((candidatePath, index) => candidatePath !== globalsPaths[index]))) return [];
+	const names = /* @__PURE__ */ new Set();
+	for (const globalsPath of globalsPaths) for (const name of collectGeneratedGlobalNames(globalsPath, rootDirectory)) names.add(name);
+	return [...names].sort();
+};
+const collectUnpluginAutoImportGlobalScopes = ({ rootDirectory, candidateFiles }) => {
+	const absoluteRootDirectory = Path.resolve(rootDirectory);
+	const packageDirectoryCache = /* @__PURE__ */ new Map();
+	const packageDirectories = /* @__PURE__ */ new Set();
+	for (const candidateFile of candidateFiles) {
+		const packageDirectory = findOwningPackageDirectory(Path.resolve(absoluteRootDirectory, candidateFile), absoluteRootDirectory, packageDirectoryCache);
+		if (packageDirectory) packageDirectories.add(packageDirectory);
+	}
+	const scopes = [...packageDirectories].map((packageDirectory) => ({
+		directory: Path.relative(absoluteRootDirectory, packageDirectory).replaceAll("\\", "/"),
+		names: collectPackageGlobalNames(packageDirectory, absoluteRootDirectory)
+	})).sort((firstScope, secondScope) => firstScope.directory.localeCompare(secondScope.directory));
+	return scopes.some((scope) => scope.names.length > 0) ? scopes : [];
+};
 const validateDiagnostic$1 = decodeUnknownSync(Diagnostic);
 const decodeFileDiagnostics = (raw) => {
 	if (!Array.isArray(raw)) return null;
@@ -70255,6 +71425,56 @@ const appendReanimatedSharedValueHint = (help, rule, project) => {
 	if (!help) return REANIMATED_SHARED_VALUE_HINT;
 	return `${help}\n\n${REANIMATED_SHARED_VALUE_HINT}`;
 };
+const columnOfUtf8Offset = (sourceBuffer, utf8Offset) => {
+	const boundedOffset = Math.min(Math.max(utf8Offset, 0), sourceBuffer.length);
+	let lineStartOffset = boundedOffset;
+	while (lineStartOffset > 0 && sourceBuffer[lineStartOffset - 1] !== 10) lineStartOffset--;
+	return sourceBuffer.subarray(lineStartOffset, boundedOffset).toString("utf8").length + 1;
+};
+const utf8OffsetFromSourcePosition = (sourceBuffer, lineNumber, zeroBasedColumn) => {
+	if (lineNumber < 1 || zeroBasedColumn < 0) return null;
+	const sourceLines = sourceBuffer.toString("utf8").split("\n");
+	const sourceLine = sourceLines[lineNumber - 1];
+	if (sourceLine === void 0 || zeroBasedColumn > sourceLine.length) return null;
+	const precedingLines = sourceLines.slice(0, lineNumber - 1).join("\n");
+	return (lineNumber === 1 ? 0 : Buffer.byteLength(precedingLines) + Buffer.byteLength("\n")) + Buffer.byteLength(sourceLine.slice(0, zeroBasedColumn));
+};
+const mapPreparedSourceSpan = (span, preparedSourceMap) => {
+	const generatedLine = lineOfUtf8Offset(preparedSourceMap.generatedBuffer, span.offset);
+	const generatedColumn = columnOfUtf8Offset(preparedSourceMap.generatedBuffer, span.offset) - 1;
+	const originalStart = originalPositionFor(preparedSourceMap.traceMap, {
+		line: generatedLine,
+		column: generatedColumn
+	});
+	if (originalStart.source === null || originalStart.line === null || originalStart.column === null) return null;
+	const originalOffset = utf8OffsetFromSourcePosition(preparedSourceMap.sourceBuffer, originalStart.line, originalStart.column);
+	if (originalOffset === null) return null;
+	const generatedSpan = preparedSourceMap.generatedBuffer.subarray(span.offset, span.offset + span.length);
+	return {
+		offset: originalOffset,
+		length: preparedSourceMap.sourceBuffer.subarray(originalOffset, originalOffset + generatedSpan.length).equals(generatedSpan) ? generatedSpan.length : 0,
+		line: originalStart.line,
+		column: originalStart.column + 1
+	};
+};
+const mapPreparedSourceLabels = (labels, preparedSourceMap) => {
+	const primaryLabel = labels[0];
+	if (primaryLabel === void 0) return null;
+	const primarySpan = mapPreparedSourceSpan(primaryLabel.span, preparedSourceMap);
+	if (primarySpan === null) return null;
+	const mappedLabels = [{
+		...primaryLabel,
+		span: primarySpan
+	}];
+	for (const relatedLabel of labels.slice(1)) {
+		const relatedSpan = mapPreparedSourceSpan(relatedLabel.span, preparedSourceMap);
+		if (relatedSpan !== null) mappedLabels.push({
+			...relatedLabel,
+			span: relatedSpan
+		});
+	}
+	return mappedLabels;
+};
 const REDACTED_PLACEHOLDER = "<redacted>";
 const KEEP_PREFIX = `$1${REDACTED_PLACEHOLDER}`;
 const KNOWN_SECRET_RULES = [
@@ -70970,7 +72190,7 @@ const resolveMatchByOccurrence = (rule, category) => OCCURRENCE_MATCHED_CATEGORI
 * with empty text still carry a useful jump target, so they're kept
 * with a neutral message.
 */
-const buildRelatedLocations = (labels, filePath) => {
+const buildRelatedLocations = (labels, filePath, sourceBuffer) => {
 	if (labels.length <= 1) return [];
 	const related = [];
 	for (let labelIndex = 1; labelIndex < labels.length; labelIndex++) {
@@ -70978,8 +72198,8 @@ const buildRelatedLocations = (labels, filePath) => {
 		if (!label?.span) continue;
 		related.push({
 			filePath,
-			line: label.span.line ?? 0,
-			column: label.span.column ?? 0,
+			line: sourceBuffer === null ? label.span.line ?? 0 : lineOfUtf8Offset(sourceBuffer, label.span.offset),
+			column: sourceBuffer === null ? label.span.column ?? 0 : columnOfUtf8Offset(sourceBuffer, label.span.offset),
 			offset: label.span.offset,
 			length: label.span.length,
 			message: label.label ?? ""
@@ -70999,7 +72219,7 @@ const isOxlintOutput = (value) => isRecord(value) && Array.isArray(value.diagnos
 * to the first `{`. Raises `OxlintOutputUnparseable` when the
 * stdout isn't valid JSON or doesn't carry a `diagnostics` array.
 */
-const parseOxlintOutput = (stdout, project, rootDirectory) => {
+const parseOxlintOutput = (stdout, project, rootDirectory, sourcePathByLintPath, sourceMapByLintPath) => {
 	if (!stdout) return [];
 	const jsonStart = stdout.indexOf("{");
 	const sanitizedStdout = jsonStart > 0 ? stdout.slice(jsonStart) : stdout;
@@ -71016,8 +72236,11 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 	const sourceBufferCache = /* @__PURE__ */ new Map();
 	const sourceLinesCache = /* @__PURE__ */ new Map();
 	const resolveAbsolutePath = (filename) => Path.isAbsolute(filename) ? filename : Path.resolve(rootDirectory || ".", filename);
+	const resolveMappedSourceFilename = (filename) => sourcePathByLintPath?.get(Path.normalize(resolveAbsolutePath(filename)));
+	const resolvePreparedSourceMap = (filename) => sourceMapByLintPath?.get(Path.normalize(resolveAbsolutePath(filename)));
+	const resolveSourceFilename = (filename) => resolveMappedSourceFilename(filename) ?? filename;
 	const readSourceBuffer = (filename) => {
-		const absolutePath = resolveAbsolutePath(filename);
+		const absolutePath = resolveAbsolutePath(resolveSourceFilename(filename));
 		const cached = sourceBufferCache.get(absolutePath);
 		if (cached !== void 0) return cached;
 		let sourceBuffer;
@@ -71030,7 +72253,7 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 		return sourceBuffer;
 	};
 	const readSourceLines = (filename) => {
-		const absolutePath = resolveAbsolutePath(filename);
+		const absolutePath = resolveAbsolutePath(resolveSourceFilename(filename));
 		const cached = sourceLinesCache.get(absolutePath);
 		if (cached !== void 0) return cached;
 		const sourceBuffer = readSourceBuffer(filename);
@@ -71039,27 +72262,42 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 		return sourceLines;
 	};
 	const isMinifiedDiagnosticFile = (filename) => {
-		const absolutePath = resolveAbsolutePath(filename);
+		const absolutePath = resolveAbsolutePath(resolveSourceFilename(filename));
 		const cached = minifiedFileCache.get(absolutePath);
 		if (cached !== void 0) return cached;
 		const minified = isMinifiedSource(absolutePath);
 		minifiedFileCache.set(absolutePath, minified);
 		return minified;
 	};
-	return suppressMemoizationInBailedOutFunctions(parsed.diagnostics.filter((diagnostic) => isMappableOxlintDiagnostic(diagnostic) && isLintableSourceFile(diagnostic.filename) && !(TYPESCRIPT_DECLARATION_FILE_PATTERN.test(diagnostic.filename) && OXLINT_IGNORED_DECLARATION_DIAGNOSTIC_CODES.has(diagnostic.code)) && !isMinifiedDiagnosticFile(diagnostic.filename) && !shouldSuppressLocalUseHookDiagnostic(diagnostic, rootDirectory) && !shouldSuppressCompilerFindingInWorklet(diagnostic, project, rootDirectory)).map((diagnostic) => {
+	return suppressMemoizationInBailedOutFunctions(parsed.diagnostics.flatMap((diagnostic) => {
+		const preparedSourceMap = resolvePreparedSourceMap(diagnostic.filename);
+		if (preparedSourceMap === void 0) return [diagnostic];
+		const { plugin, rule } = parseRuleCode(diagnostic.code);
+		if (plugin !== "react-doctor" || !reactDoctorPlugin.rules[rule]?.tags?.includes("design")) return [];
+		const labels = mapPreparedSourceLabels(diagnostic.labels, preparedSourceMap);
+		const sourceFilename = resolveMappedSourceFilename(diagnostic.filename);
+		return labels === null || sourceFilename === void 0 ? [] : [{
+			...diagnostic,
+			filename: sourceFilename,
+			labels
+		}];
+	}).filter((diagnostic) => isMappableOxlintDiagnostic(diagnostic) && isLintableSourceFile(resolveSourceFilename(diagnostic.filename)) && !(TYPESCRIPT_DECLARATION_FILE_PATTERN.test(diagnostic.filename) && OXLINT_IGNORED_DECLARATION_DIAGNOSTIC_CODES.has(diagnostic.code)) && !isMinifiedDiagnosticFile(diagnostic.filename) && !shouldSuppressLocalUseHookDiagnostic(diagnostic, rootDirectory) && !shouldSuppressCompilerFindingInWorklet(diagnostic, project, rootDirectory)).map((diagnostic) => {
 		const { plugin, rule } = parseRuleCode(diagnostic.code);
 		const primaryLabel = diagnostic.labels[0];
 		const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule, project);
-		const normalizedFilePath = diagnostic.filename.replaceAll("\\", "/");
+		const mappedSourceFilename = resolveMappedSourceFilename(diagnostic.filename);
+		const normalizedFilePath = (mappedSourceFilename ?? diagnostic.filename).replaceAll("\\", "/");
 		const primarySpan = primaryLabel?.span;
 		const sourceBuffer = primarySpan ? readSourceBuffer(diagnostic.filename) : null;
-		const relatedLocations = buildRelatedLocations(diagnostic.labels, normalizedFilePath);
+		const relatedLocations = buildRelatedLocations(diagnostic.labels, normalizedFilePath, mappedSourceFilename === void 0 ? null : sourceBuffer);
 		const category = resolveDiagnosticCategory(plugin, rule);
 		const matchByOccurrence = resolveMatchByOccurrence(rule, category);
 		const sourceLines = primarySpan ? readSourceLines(diagnostic.filename) : null;
-		const primaryLineIndex = primarySpan ? primarySpan.line - 1 : -1;
+		const primaryLineNumber = primarySpan && mappedSourceFilename !== void 0 && sourceBuffer !== null ? lineOfUtf8Offset(sourceBuffer, primarySpan.offset) : primarySpan?.line ?? 0;
+		const primaryColumnNumber = primarySpan && mappedSourceFilename !== void 0 && sourceBuffer !== null ? columnOfUtf8Offset(sourceBuffer, primarySpan.offset) : primarySpan?.column ?? 0;
+		const primaryLineIndex = primarySpan ? primaryLineNumber - 1 : -1;
 		const primaryLine = sourceLines?.[primaryLineIndex];
-		const primaryColumnIndex = primarySpan ? primarySpan.column - 1 : -1;
+		const primaryColumnIndex = primarySpan ? primaryColumnNumber - 1 : -1;
 		const isJsxTagLabel = primaryLine !== void 0 && primaryColumnIndex >= 0 && (primaryLine[primaryColumnIndex] === "<" || primaryLine[primaryColumnIndex - 1] === "<");
 		const jsxOpenerEndLineIndex = sourceLines && isJsxTagLabel ? findJsxOpenerSpan(sourceLines, primaryLineIndex) : null;
 		const primarySpanEndLine = jsxOpenerEndLineIndex !== null ? jsxOpenerEndLineIndex + 1 : primarySpan && sourceBuffer ? lineOfUtf8Offset(sourceBuffer, primarySpan.offset + Math.max(primarySpan.length - 1, 0)) : void 0;
@@ -71072,8 +72310,8 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 			message: cleaned.message,
 			help: cleaned.help,
 			url: diagnostic.url,
-			line: primarySpan?.line ?? 0,
-			column: primarySpan?.column ?? 0,
+			line: primaryLineNumber,
+			column: primaryColumnNumber,
 			...primarySpan ? {
 				offset: primarySpan.offset,
 				length: primarySpan.length,
@@ -71261,7 +72499,11 @@ const isParallelismRelatedSpawnError = (error) => {
 * loop with a slimmer config in that case.
 */
 const spawnLintBatches = async (input) => {
-	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal, deadlineEpochMs } = input;
+	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, sourcePathByLintPath, sourceMapByLintPath, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal, deadlineEpochMs } = input;
+	const resolveSourcePath = (filePath) => {
+		const absoluteFilePath = Path.isAbsolute(filePath) ? filePath : Path.resolve(rootDirectory, filePath);
+		return sourcePathByLintPath?.get(Path.normalize(absoluteFilePath)) ?? filePath;
+	};
 	const requestedConcurrency = resolveScanConcurrency(input.concurrency ?? 1);
 	let rescueDeadlineEpochMs;
 	const isPastDeadline = () => deadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(deadlineEpochMs) === 0 || rescueDeadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(rescueDeadlineEpochMs) === 0;
@@ -71281,7 +72523,7 @@ const spawnLintBatches = async (input) => {
 			}
 			const batchArgs = [...baseArgs, ...batch];
 			try {
-				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory);
+				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory, sourcePathByLintPath, sourceMapByLintPath);
 			} catch (error) {
 				if (!isSplittableReactDoctorError(error)) throw error;
 				if (isPastDeadline()) {
@@ -71387,10 +72629,12 @@ const spawnLintBatches = async (input) => {
 		onPartialFailure(buildMessage(`${skippedFiles.slice(0, 3).join(", ")}${skippedFiles.length > 3 ? `, +${skippedFiles.length - 3} more` : ""}`));
 	};
 	const reasonHint = firstDropReason ? ` — first failure: ${firstDropReason}` : "";
-	reportSkippedFiles(droppedFiles, (fileListPreview) => `${droppedFiles.length} file(s) failed to lint and were skipped (${fileListPreview})${reasonHint}`);
-	reportSkippedFiles(outcome.deadlineSkippedFiles, (fileListPreview) => `${outcome.deadlineSkippedFiles.length} file(s) skipped — max scan duration reached before they were linted (${fileListPreview})`);
+	const droppedSourceFiles = [...new Set(droppedFiles.map(resolveSourcePath))];
+	const deadlineSkippedSourceFiles = [...new Set(outcome.deadlineSkippedFiles.map(resolveSourcePath))];
+	reportSkippedFiles(droppedSourceFiles, (fileListPreview) => `${droppedSourceFiles.length} file(s) failed to lint and were skipped (${fileListPreview})${reasonHint}`);
+	reportSkippedFiles(deadlineSkippedSourceFiles, (fileListPreview) => `${deadlineSkippedSourceFiles.length} file(s) skipped — max scan duration reached before they were linted (${fileListPreview})`);
 	const unavailableFiles = new Set([...droppedFiles, ...outcome.deadlineSkippedFiles]);
-	input.onAnalyzedFiles?.([...new Set(fileBatches.flat().filter((filePath) => !unavailableFiles.has(filePath)))].sort());
+	input.onAnalyzedFiles?.([...new Set(fileBatches.flat().filter((filePath) => !unavailableFiles.has(filePath)).map(resolveSourcePath))].sort());
 	return dedupeDiagnostics(diagnostics);
 };
 let didValidate = false;
@@ -71489,6 +72733,294 @@ const planLintBatches = ({ baseArgs, files, sizeByFile }) => {
 	}
 	return batches.filter((batch) => batch.fileIndexes.length > 0).map((batch) => batch.fileIndexes.sort((leftIndex, rightIndex) => leftIndex - rightIndex).map((fileIndex) => files[fileIndex]));
 };
+const THREE_MODULE_IMPORT_PATTERN = /\b(?:from\s*|import\s*(?:\(\s*)?|require\s*\(\s*)["']three(?:\/[^"']*)?["']/;
+const containsThreeModuleImport = (sourceText) => THREE_MODULE_IMPORT_PATTERN.test(sourceText);
+const COMMENT_OPEN = "<!--";
+const COMMENT_CLOSE = "-->";
+const FRONTMATTER_FENCE = "---";
+const SCRIPT_TAG_NAME = "script";
+const SCRIPT_OPEN = `<${SCRIPT_TAG_NAME}`;
+const SCRIPT_CLOSE = `</${SCRIPT_TAG_NAME}`;
+const TEMPLATE_TAG_NAME = "template";
+const TEMPLATE_CLOSE = `</${TEMPLATE_TAG_NAME}`;
+const JAVASCRIPT_MIME_TYPES = new Set([
+	"application/ecmascript",
+	"application/javascript",
+	"application/x-ecmascript",
+	"application/x-javascript",
+	"text/ecmascript",
+	"text/javascript",
+	"text/javascript1.0",
+	"text/javascript1.1",
+	"text/javascript1.2",
+	"text/javascript1.3",
+	"text/javascript1.4",
+	"text/javascript1.5",
+	"text/jscript",
+	"text/livescript",
+	"text/x-ecmascript",
+	"text/x-javascript"
+]);
+const RAW_TEXT_TAG_NAMES = new Set([
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"style",
+	"textarea",
+	"title",
+	"xmp"
+]);
+const PLAINTEXT_TAG_NAME = "plaintext";
+const TAG_OPEN_UTF8_BYTE = "<".charCodeAt(0);
+const TAG_CLOSE_UTF8_BYTE = ">".charCodeAt(0);
+const SINGLE_QUOTE_UTF8_BYTE = "'".charCodeAt(0);
+const DOUBLE_QUOTE_UTF8_BYTE = "\"".charCodeAt(0);
+const ATTRIBUTE_ASSIGNMENT_UTF8_BYTE = "=".charCodeAt(0);
+const TAG_SELF_CLOSE_UTF8_BYTE = "/".charCodeAt(0);
+const TAB_UTF8_BYTE = "	".charCodeAt(0);
+const FORM_FEED_UTF8_BYTE = "\f".charCodeAt(0);
+const isHtmlWhitespace = (byte) => byte === TAB_UTF8_BYTE || byte === 10 || byte === FORM_FEED_UTF8_BYTE || byte === 13 || byte === 32;
+const matchesAsciiCaseInsensitive = (sourceBuffer, startByte, expected) => {
+	if (startByte + expected.length > sourceBuffer.length) return false;
+	for (let expectedIndex = 0; expectedIndex < expected.length; expectedIndex++) {
+		const sourceByte = sourceBuffer[startByte + expectedIndex];
+		if (sourceByte === void 0 || String.fromCharCode(sourceByte).toLowerCase() !== expected[expectedIndex]) return false;
+	}
+	return true;
+};
+const isTagBoundary = (byte) => byte === TAG_CLOSE_UTF8_BYTE || byte === TAG_SELF_CLOSE_UTF8_BYTE || isHtmlWhitespace(byte);
+const isPotentialTagStart = (byte) => {
+	if (byte === void 0) return false;
+	return /[A-Za-z!/?]/.test(String.fromCharCode(byte));
+};
+const findLineEnd = (sourceBuffer, lineStartByte) => {
+	let byteIndex = lineStartByte;
+	while (byteIndex < sourceBuffer.length && sourceBuffer[byteIndex] !== 10 && sourceBuffer[byteIndex] !== 13) byteIndex++;
+	return byteIndex;
+};
+const findNextLineStart = (sourceBuffer, lineStartByte) => {
+	const lineEndByte = findLineEnd(sourceBuffer, lineStartByte);
+	if (sourceBuffer[lineEndByte] === 13 && sourceBuffer[lineEndByte + 1] === 10) return lineEndByte + 2;
+	return Math.min(lineEndByte + 1, sourceBuffer.length);
+};
+const isFrontmatterFenceLine = (sourceBuffer, lineStartByte) => {
+	if (!matchesAsciiCaseInsensitive(sourceBuffer, lineStartByte, FRONTMATTER_FENCE)) return false;
+	const lineEndByte = findLineEnd(sourceBuffer, lineStartByte);
+	for (let byteIndex = lineStartByte + 3; byteIndex < lineEndByte; byteIndex++) if (!isHtmlWhitespace(sourceBuffer[byteIndex])) return false;
+	return true;
+};
+const findFrontmatterEnd = (sourceBuffer) => {
+	if (!isFrontmatterFenceLine(sourceBuffer, 0)) return 0;
+	const openingFenceEndByte = findLineEnd(sourceBuffer, 0);
+	let lineStartByte = findNextLineStart(sourceBuffer, 0);
+	while (lineStartByte < sourceBuffer.length) {
+		if (isFrontmatterFenceLine(sourceBuffer, lineStartByte)) return findLineEnd(sourceBuffer, lineStartByte);
+		lineStartByte = findNextLineStart(sourceBuffer, lineStartByte);
+	}
+	return openingFenceEndByte;
+};
+const maskByteRange = (maskedBuffer, startByte, endByte) => {
+	for (let byteIndex = startByte; byteIndex < endByte; byteIndex++) {
+		const byte = maskedBuffer[byteIndex];
+		if (byte !== 10 && byte !== 13) maskedBuffer[byteIndex] = 32;
+	}
+};
+const readStartTagName = (sourceBuffer, tagStartByte) => {
+	const firstNameByte = sourceBuffer[tagStartByte + 1];
+	if (firstNameByte === void 0 || !/[A-Za-z]/.test(String.fromCharCode(firstNameByte))) return null;
+	let nameEndByte = tagStartByte + 2;
+	while (nameEndByte < sourceBuffer.length && /[A-Za-z0-9:-]/.test(String.fromCharCode(sourceBuffer[nameEndByte] ?? 32))) nameEndByte++;
+	return sourceBuffer.subarray(tagStartByte + 1, nameEndByte).toString("ascii").toLowerCase();
+};
+const findTagEnd = (sourceBuffer, startByte) => {
+	let quoteByte = null;
+	for (let byteIndex = startByte; byteIndex < sourceBuffer.length; byteIndex++) {
+		const byte = sourceBuffer[byteIndex];
+		if (quoteByte !== null) {
+			if (byte === quoteByte) quoteByte = null;
+			continue;
+		}
+		if (byte === SINGLE_QUOTE_UTF8_BYTE || byte === DOUBLE_QUOTE_UTF8_BYTE) {
+			quoteByte = byte;
+			continue;
+		}
+		if (byte === TAG_CLOSE_UTF8_BYTE) return byteIndex;
+	}
+	return sourceBuffer.length;
+};
+const parseScriptAttributes = (sourceBuffer, attributesStartByte, tagEndByte) => {
+	let byteIndex = attributesStartByte;
+	let hasSource = false;
+	let language = null;
+	let scriptType = null;
+	while (byteIndex < tagEndByte) {
+		while (byteIndex < tagEndByte && (isHtmlWhitespace(sourceBuffer[byteIndex]) || sourceBuffer[byteIndex] === TAG_SELF_CLOSE_UTF8_BYTE)) byteIndex++;
+		const attributeNameStartByte = byteIndex;
+		while (byteIndex < tagEndByte && !isHtmlWhitespace(sourceBuffer[byteIndex]) && sourceBuffer[byteIndex] !== ATTRIBUTE_ASSIGNMENT_UTF8_BYTE && sourceBuffer[byteIndex] !== TAG_SELF_CLOSE_UTF8_BYTE) byteIndex++;
+		const attributeName = sourceBuffer.subarray(attributeNameStartByte, byteIndex).toString("ascii").toLowerCase();
+		while (byteIndex < tagEndByte && isHtmlWhitespace(sourceBuffer[byteIndex])) byteIndex++;
+		let attributeValue = "";
+		if (sourceBuffer[byteIndex] === ATTRIBUTE_ASSIGNMENT_UTF8_BYTE) {
+			byteIndex++;
+			while (byteIndex < tagEndByte && isHtmlWhitespace(sourceBuffer[byteIndex])) byteIndex++;
+			const quoteByte = sourceBuffer[byteIndex];
+			if (quoteByte === SINGLE_QUOTE_UTF8_BYTE || quoteByte === DOUBLE_QUOTE_UTF8_BYTE) {
+				const valueStartByte = byteIndex + 1;
+				byteIndex = valueStartByte;
+				while (byteIndex < tagEndByte && sourceBuffer[byteIndex] !== quoteByte) byteIndex++;
+				attributeValue = sourceBuffer.subarray(valueStartByte, byteIndex).toString("utf8");
+				if (byteIndex < tagEndByte) byteIndex++;
+			} else {
+				const valueStartByte = byteIndex;
+				while (byteIndex < tagEndByte && !isHtmlWhitespace(sourceBuffer[byteIndex]) && sourceBuffer[byteIndex] !== TAG_CLOSE_UTF8_BYTE) byteIndex++;
+				attributeValue = sourceBuffer.subarray(valueStartByte, byteIndex).toString("utf8");
+			}
+		}
+		if (attributeName === "src") hasSource = true;
+		else if (attributeName === "type" && scriptType === null) scriptType = attributeValue;
+		else if (attributeName === "language" && language === null) language = attributeValue;
+	}
+	return {
+		hasSource,
+		language,
+		type: scriptType
+	};
+};
+const isExecutableScript = (attributes) => {
+	if (attributes.hasSource) return false;
+	const type = attributes.type?.trim().toLowerCase() ?? "";
+	if (type !== "") {
+		const mimeType = type.split(";")[0]?.trim() ?? "";
+		return mimeType === "module" || JAVASCRIPT_MIME_TYPES.has(mimeType);
+	}
+	const language = attributes.language?.trim().toLowerCase() ?? "";
+	return language === "" || JAVASCRIPT_MIME_TYPES.has(`text/${language}`);
+};
+const findElementClose = (sourceBuffer, startByte, tagName) => {
+	const closeTagStart = `</${tagName}`;
+	for (let byteIndex = startByte; byteIndex < sourceBuffer.length; byteIndex++) if (sourceBuffer[byteIndex] === TAG_OPEN_UTF8_BYTE && matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, closeTagStart) && isTagBoundary(sourceBuffer[byteIndex + closeTagStart.length])) return byteIndex;
+	return sourceBuffer.length;
+};
+const prepareHtmlScriptSource = (sourceBuffer) => {
+	const frontmatterEndByte = findFrontmatterEnd(sourceBuffer);
+	let maskedBuffer = frontmatterEndByte > 0 ? Buffer.from(sourceBuffer) : null;
+	if (maskedBuffer !== null) maskByteRange(maskedBuffer, 0, frontmatterEndByte);
+	const executableScriptBodies = [];
+	let byteIndex = frontmatterEndByte;
+	let templateDepth = 0;
+	while (byteIndex < sourceBuffer.length) {
+		if (sourceBuffer[byteIndex] !== TAG_OPEN_UTF8_BYTE) {
+			byteIndex++;
+			continue;
+		}
+		if (matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, COMMENT_OPEN)) {
+			const commentEndByte = sourceBuffer.indexOf(COMMENT_CLOSE, byteIndex + 4);
+			byteIndex = commentEndByte === -1 ? sourceBuffer.length : commentEndByte + 3;
+			continue;
+		}
+		if (matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, TEMPLATE_CLOSE) && isTagBoundary(sourceBuffer[byteIndex + TEMPLATE_CLOSE.length])) {
+			const tagEndByte = findTagEnd(sourceBuffer, byteIndex + TEMPLATE_CLOSE.length);
+			if (templateDepth > 0) templateDepth--;
+			byteIndex = Math.min(tagEndByte + 1, sourceBuffer.length);
+			continue;
+		}
+		if (!matchesAsciiCaseInsensitive(sourceBuffer, byteIndex, SCRIPT_OPEN) || !isTagBoundary(sourceBuffer[byteIndex + SCRIPT_OPEN.length])) {
+			if (!isPotentialTagStart(sourceBuffer[byteIndex + 1])) {
+				byteIndex++;
+				continue;
+			}
+			const tagEndByte = findTagEnd(sourceBuffer, byteIndex + 1);
+			const tagName = readStartTagName(sourceBuffer, byteIndex);
+			if (tagName === PLAINTEXT_TAG_NAME) break;
+			if (tagName === TEMPLATE_TAG_NAME) templateDepth++;
+			if (tagName !== null && RAW_TEXT_TAG_NAMES.has(tagName)) {
+				const closeTagStartByte = findElementClose(sourceBuffer, tagEndByte + 1, tagName);
+				if (closeTagStartByte === sourceBuffer.length) break;
+				const closeTagEndByte = findTagEnd(sourceBuffer, closeTagStartByte + tagName.length + 2);
+				byteIndex = Math.min(closeTagEndByte + 1, sourceBuffer.length);
+				continue;
+			}
+			byteIndex = Math.min(tagEndByte + 1, sourceBuffer.length);
+			continue;
+		}
+		const tagEndByte = findTagEnd(sourceBuffer, byteIndex + SCRIPT_OPEN.length);
+		if (tagEndByte === sourceBuffer.length) break;
+		const bodyStartByte = tagEndByte + 1;
+		const bodyEndByte = findElementClose(sourceBuffer, bodyStartByte, SCRIPT_TAG_NAME);
+		const attributes = parseScriptAttributes(sourceBuffer, byteIndex + SCRIPT_OPEN.length, tagEndByte);
+		if (attributes.hasSource || templateDepth > 0) {
+			maskedBuffer ??= Buffer.from(sourceBuffer);
+			maskByteRange(maskedBuffer, bodyStartByte, bodyEndByte);
+		} else if (isExecutableScript(attributes)) executableScriptBodies.push(sourceBuffer.subarray(bodyStartByte, bodyEndByte));
+		if (bodyEndByte === sourceBuffer.length) break;
+		const closeTagEndByte = findTagEnd(sourceBuffer, bodyEndByte + SCRIPT_CLOSE.length);
+		byteIndex = Math.min(closeTagEndByte + 1, sourceBuffer.length);
+	}
+	return {
+		executableScriptBodies,
+		lintBuffer: maskedBuffer ?? sourceBuffer
+	};
+};
+const ASTRO_FILE_PATTERN = /\.astro$/;
+const prepareLintSources = (rootDirectory, temporaryDirectory, candidateFiles) => {
+	const lintFiles = [];
+	const sourcePathByLintPath = /* @__PURE__ */ new Map();
+	const sourceMapByLintPath = /* @__PURE__ */ new Map();
+	const sizeByLintPath = /* @__PURE__ */ new Map();
+	const htmlSourcesDirectory = Path.join(temporaryDirectory, "html-sources");
+	const astroSourcesDirectory = Path.join(temporaryDirectory, "astro-sources");
+	let htmlFileIndex = 0;
+	let astroFileIndex = 0;
+	let hasThreeModuleImport = false;
+	for (const candidateFile of candidateFiles) {
+		if (!HTML_FILE_PATTERN.test(candidateFile) && !ASTRO_FILE_PATTERN.test(candidateFile)) {
+			lintFiles.push(candidateFile);
+			continue;
+		}
+		const absoluteSourcePath = Path.isAbsolute(candidateFile) ? candidateFile : Path.resolve(rootDirectory, candidateFile);
+		const sourceBuffer = NFS.readFileSync(absoluteSourcePath);
+		if (ASTRO_FILE_PATTERN.test(candidateFile)) {
+			const compilerSourcePath = absoluteSourcePath.replaceAll("\\", "/");
+			const convertedSource = convertToTSX(sourceBuffer.toString("utf8"), {
+				filename: compilerSourcePath,
+				sourcemap: "external",
+				includeScripts: true
+			});
+			if (astroFileIndex === 0) NFS.mkdirSync(astroSourcesDirectory, { recursive: true });
+			const lintPath = Path.join(astroSourcesDirectory, `${astroFileIndex}.tsx`);
+			const generatedBuffer = Buffer.from(convertedSource.code);
+			NFS.writeFileSync(lintPath, generatedBuffer);
+			lintFiles.push(candidateFile);
+			lintFiles.push(lintPath);
+			sourcePathByLintPath.set(Path.resolve(lintPath), candidateFile);
+			sourceMapByLintPath.set(Path.resolve(lintPath), {
+				traceMap: new TraceMap(JSON.stringify(convertedSource.map)),
+				generatedBuffer,
+				sourceBuffer
+			});
+			sizeByLintPath.set(lintPath, sourceBuffer.length);
+			astroFileIndex++;
+			continue;
+		}
+		const { executableScriptBodies, lintBuffer } = prepareHtmlScriptSource(sourceBuffer);
+		if (htmlFileIndex === 0) NFS.mkdirSync(htmlSourcesDirectory, { recursive: true });
+		const lintPath = Path.join(htmlSourcesDirectory, `${htmlFileIndex}.astro`);
+		NFS.writeFileSync(lintPath, lintBuffer);
+		lintFiles.push(lintPath);
+		sourcePathByLintPath.set(Path.resolve(lintPath), candidateFile);
+		sizeByLintPath.set(lintPath, sourceBuffer.length);
+		hasThreeModuleImport ||= executableScriptBodies.some((scriptBody) => containsThreeModuleImport(scriptBody.toString("utf8")));
+		htmlFileIndex++;
+	}
+	return {
+		lintFiles,
+		sourcePathByLintPath,
+		sourceMapByLintPath,
+		sizeByLintPath,
+		hasThreeModuleImport
+	};
+};
 /**
 * Atomically (re)writes the generated oxlintrc.json. Used twice in
 * the runner: once for the primary scan, once for the
@@ -71649,6 +73181,8 @@ const reactHooksJsPluginDropNote = (error) => {
 const runOxlint = async (options) => {
 	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), includedTags = /* @__PURE__ */ new Set(), includeTagDefaults = false, userConfig, configSourceDirectory = rootDirectory, onPartialFailure, onFileCoverage, perFileLintCacheEnabled = false, sidecarLintCacheEnabled = false, onCacheStats, onSidecarStats, spawnTimeoutMs, outputMaxBytes, lintBatchOrdering = "cost" } = options;
 	const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames) ? userConfig.serverAuthFunctionNames.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
+	const runtimeGlobals = Array.isArray(userConfig?.runtimeGlobals) ? userConfig.runtimeGlobals.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
+	let unpluginAutoImportGlobalScopes = [];
 	const severityControls = buildRuleSeverityControls(userConfig);
 	validateRuleRegistration();
 	resetManifestCaches();
@@ -71662,21 +73196,6 @@ const runOxlint = async (options) => {
 	const pluginPath = resolvePluginPath();
 	const extendsPaths = (adoptExistingLintConfig && !customRulesOnly ? detectUserLintConfigPaths(rootDirectory) : []).filter(canOxlintExtendConfig);
 	const userPlugins = includedTags.size > 0 ? [] : resolveUserPlugins(userConfig?.plugins, configSourceDirectory);
-	const buildConfig = (overrides) => createOxlintConfig({
-		pluginPath,
-		project,
-		customRulesOnly,
-		extendsPaths: overrides.extendsPaths,
-		ignoredTags,
-		includedTags,
-		includeTagDefaults,
-		serverAuthFunctionNames,
-		severityControls,
-		userPlugins,
-		disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin,
-		ruleSelection: overrides.ruleSelection,
-		sidecarRuleIdFilter: overrides.sidecarRuleIdFilter
-	});
 	const restoreDisableDirectives = respectInlineDisables ? () => {} : await neutralizeDisableDirectives(rootDirectory, includePaths);
 	const configDirectory = NFS.mkdtempSync(Path.join(os.tmpdir(), "react-doctor-oxlintrc-"));
 	const configPath = Path.join(configDirectory, "oxlintrc.json");
@@ -71712,7 +73231,36 @@ const runOxlint = async (options) => {
 		await yieldToEventLoop();
 		const sizedScanFiles = includePaths === void 0 ? listSourceFilesWithSize(rootDirectory) : null;
 		const candidateFiles = includePaths !== void 0 ? includePaths : (sizedScanFiles ?? []).map((entry) => entry.path);
+		unpluginAutoImportGlobalScopes = collectUnpluginAutoImportGlobalScopes({
+			rootDirectory,
+			candidateFiles
+		});
+		const preparedLintSources = prepareLintSources(rootDirectory, configDirectory, candidateFiles);
+		const lintFiles = preparedLintSources.lintFiles;
+		const hasPreparedFiles = preparedLintSources.sourcePathByLintPath.size > 0;
+		const lintProject = !project.hasThree && preparedLintSources.hasThreeModuleImport ? {
+			...project,
+			hasThree: true
+		} : project;
+		const buildConfig = (overrides) => createOxlintConfig({
+			pluginPath,
+			project: lintProject,
+			customRulesOnly,
+			extendsPaths: overrides.extendsPaths,
+			ignoredTags,
+			includedTags,
+			includeTagDefaults,
+			runtimeGlobals,
+			unpluginAutoImportGlobalScopes,
+			serverAuthFunctionNames,
+			severityControls,
+			userPlugins,
+			disableReactHooksJsPlugin: overrides.disableReactHooksJsPlugin,
+			ruleSelection: overrides.ruleSelection,
+			sidecarRuleIdFilter: overrides.sidecarRuleIdFilter
+		});
 		const sizeByFile = sizedScanFiles !== null && lintBatchOrdering === "cost" ? new Map(sizedScanFiles.map((entry) => [entry.path, entry.sizeBytes])) : null;
+		if (sizeByFile !== null) for (const [lintPath, sizeBytes] of preparedLintSources.sizeByLintPath) sizeByFile.set(lintPath, sizeBytes);
 		const buildFileBatches = (passBaseArgs, passFiles) => sizeByFile !== null ? planLintBatches({
 			baseArgs: passBaseArgs,
 			files: passFiles,
@@ -71741,7 +73289,9 @@ const runOxlint = async (options) => {
 					fileBatches: passFileBatches,
 					rootDirectory,
 					nodeBinaryPath,
-					project,
+					project: lintProject,
+					sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+					sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 					onPartialFailure: reportPartialFailure,
 					onAnalyzedFiles: (filePaths) => {
 						analyzedFiles = filePaths;
@@ -71776,7 +73326,7 @@ const runOxlint = async (options) => {
 				};
 			}
 		};
-		if (perFileLintCacheEnabled && !project.hasReactCompiler && project.hasReactCompilerLintPlugin !== true && extendsPaths.length === 0 && userPlugins.length === 0) {
+		if (perFileLintCacheEnabled && !project.hasReactCompiler && project.hasReactCompilerLintPlugin !== true && extendsPaths.length === 0 && userPlugins.length === 0 && !hasPreparedFiles) {
 			const rulesetHash = computeRulesetHash({
 				config: buildConfig({
 					extendsPaths: [],
@@ -71934,14 +73484,16 @@ const runOxlint = async (options) => {
 			]);
 		}
 		const baseArgs = makeBaseArgs(configPath);
-		const fileBatches = buildFileBatches(baseArgs, candidateFiles);
+		const fileBatches = buildFileBatches(baseArgs, lintFiles);
 		let analyzedFiles = [];
 		const runBatches = () => spawnLintBatches({
 			baseArgs,
 			fileBatches,
 			rootDirectory,
 			nodeBinaryPath,
-			project,
+			project: lintProject,
+			sourcePathByLintPath: preparedLintSources.sourcePathByLintPath,
+			sourceMapByLintPath: preparedLintSources.sourceMapByLintPath,
 			onPartialFailure,
 			onAnalyzedFiles: (filePaths) => {
 				analyzedFiles = filePaths;
@@ -73290,10 +74842,14 @@ const materializeSourceTree = (input) => gen(function* () {
 		materializedFiles.push(relativePath);
 	}
 	yield* sync(() => {
-		for (const configFilename of STAGED_FILES_PROJECT_CONFIG_FILENAMES) {
-			const sourcePath = path.join(input.directory, configFilename);
-			const targetPath = path.join(resolvedTempDirectory, configFilename);
-			if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) fs.cpSync(sourcePath, targetPath);
+		for (const subdirectory of ["", ...input.configSubdirectories ?? []]) for (const configFilename of STAGED_FILES_PROJECT_CONFIG_FILENAMES) {
+			const sourcePath = path.join(input.directory, subdirectory, configFilename);
+			const targetPath = path.resolve(resolvedTempDirectory, subdirectory, configFilename);
+			if (!isPathInsideDirectory(targetPath, resolvedTempDirectory)) continue;
+			if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
+				fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+				fs.cpSync(sourcePath, targetPath);
+			}
 		}
 	});
 	return {
@@ -73314,15 +74870,17 @@ const materializeSourceTree = (input) => gen(function* () {
 	static layerNode = effect(StagedFiles, gen(function* () {
 		const git = yield* Git;
 		return StagedFiles.of({
-			discoverSourceFiles: (directory) => git.stagedFilePaths(directory).pipe(map$3((entries) => entries.filter(isLintableSourceFile)), withSpan("StagedFiles.discoverSourceFiles")),
-			materialize: ({ directory, stagedFiles, tempDirectory }) => materializeSourceTree({
+			discoverSourceFiles: (directory) => git.stagedFilePaths(directory).pipe(map$3((entries) => entries === null ? null : entries.filter(isLintableSourceFile)), withSpan("StagedFiles.discoverSourceFiles")),
+			materialize: ({ directory, stagedFiles, tempDirectory, configSubdirectories }) => materializeSourceTree({
 				directory,
 				files: stagedFiles,
 				tempDirectory,
+				configSubdirectories,
 				readContent: (relativePath) => git.showStagedContent(directory, relativePath, { maxBufferBytes: GIT_SHOW_MAX_BUFFER_BYTES })
 			}).pipe(map$3((tree) => ({
 				tempDirectory: tree.tempDirectory,
 				stagedFiles: tree.materializedFiles,
+				unmaterializedFiles: tree.unmaterializedFiles,
 				cleanup: tree.cleanup
 			})), withSpan("StagedFiles.materialize"))
 		});
@@ -73337,6 +74895,7 @@ const materializeSourceTree = (input) => gen(function* () {
 		materialize: ({ tempDirectory }) => succeed$2({
 			tempDirectory,
 			stagedFiles: snapshot.materializedFiles ?? snapshot.sourceFiles ?? [],
+			unmaterializedFiles: [],
 			cleanup: () => {}
 		})
 	}));
@@ -73475,7 +75034,7 @@ const computeConfigFingerprint = (projectDirectory, version) => {
 /** Display name used in client-facing messages and progress titles. */
 const SERVER_DISPLAY_NAME = "React Doctor";
 /** Server version reported in `serverInfo`; injected at build, `dev` from source. */
-const SERVER_VERSION = "0.9.1";
+const SERVER_VERSION = "0.9.2";
 /** `Diagnostic.source` shown next to every published diagnostic. */
 const DIAGNOSTIC_SOURCE = "react-doctor";
 /**
@@ -73517,7 +75076,8 @@ const SCANNABLE_EXTENSIONS = [
 	".js",
 	".jsx",
 	".mts",
-	".mjs"
+	".mjs",
+	".html"
 ];
 const SILENT_LOGGER = {
 	info: () => {},
@@ -75168,11 +76728,13 @@ const METRIC = {
 	cliError: "cli.error",
 	cliEnvironmentError: "cli.env_error",
 	stagedSnapshotDivergence: "staged.snapshot_divergence",
+	stagedPerProject: "staged.per_project",
 	projectDetected: "project.detected",
 	projectPathSelected: "project.path_selected",
 	projectConfigSelected: "project.config_selected",
 	scanCompleted: "scan.completed",
 	scanDuration: "scan.duration",
+	scanFeedbackDelay: "scan.feedback_delay",
 	scanPhaseDuration: "scan.phase_duration",
 	scanFiles: "scan.files",
 	scanScore: "scan.score",
@@ -75204,6 +76766,10 @@ const METRIC = {
 	lspScanCompleted: "lsp.scan.completed",
 	lspScanDuration: "lsp.scan.duration",
 	lspScanDiagnostics: "lsp.scan.diagnostics",
+	tuiActionMenuOpened: "tui.action_menu_opened",
+	tuiCompactReportShown: "tui.compact_report_shown",
+	tuiFindingNavigated: "tui.finding_navigated",
+	tuiStackedReportCapped: "tui.stacked_report_capped",
 	aiTrainingWarningShown: "ai.training.warning_shown",
 	jsonOutUsed: "json.out_used"
 };
@@ -75505,5 +77071,5 @@ const startLanguageServer = () => {
 };
 //#endregion
 export { startLanguageServer };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="aeb8bc8c-7094-5b26-bb18-e269e2d4318a")}catch(e){}}();
-//# debugId=aeb8bc8c-7094-5b26-bb18-e269e2d4318a
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7cb1cf13-9787-536b-856a-49d43fec26a4")}catch(e){}}();
+//# debugId=7cb1cf13-9787-536b-856a-49d43fec26a4