react-doctor 0.9.1-dev.5d2f66d → 0.9.1-dev.6904ff1

package/dist/lsp.js

@@ -10,6 +10,7 @@ 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";
@@ -61478,7 +61479,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 = /\.(?: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;
@@ -62095,7 +62097,7 @@ const findMonorepoRoot = (startDirectory) => {
 */
 const isProjectBoundary = (directory) => NFS.existsSync(Path.join(directory, ".git")) || isMonorepoRoot(directory);
 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 +62114,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) => {
@@ -62306,6 +62313,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 +62345,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}`)] : [
@@ -62341,7 +62369,7 @@ const parseConfigSourceFile = (filePath, content) => filePath.endsWith(".json")
 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 +62382,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,21 +62413,21 @@ 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$2(bindingElement.propertyName) ?? bindingElement.propertyName.getText(sourceFile) : bindingElement.name.getText(sourceFile),
@@ -62455,6 +62483,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;
@@ -62738,6 +62808,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);
+};
 const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, isCompilerTransformCollection, excludedPropertyNames) => {
 	const assignedReactCompiler = getAssignedPropertyInitializer(identifier, "reactCompiler");
 	if (assignedReactCompiler.initializer && !isStaticallyDisabledConfigExpression(assignedReactCompiler.initializer, analysis)) return true;
@@ -62758,30 +62833,62 @@ const analyzeConfigIdentifier = (identifier, analysis, allowCompilerTransform, i
 	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;
@@ -62804,9 +62911,13 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 			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$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)) {
@@ -62830,23 +62941,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,27 +62978,31 @@ 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, 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);
@@ -62885,13 +63013,19 @@ const analyzeConfigNode = (node, analysis, allowCompilerTransform, isCompilerTra
 	}
 	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, 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);
@@ -62929,14 +63063,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);
 	}
@@ -66165,7 +66304,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 +66408,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);
@@ -70028,7 +70167,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;
 };
@@ -70187,13 +70330,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];
@@ -70239,8 +70383,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] } : {}
 		} },
@@ -70251,6 +70403,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;
@@ -70573,6 +70964,12 @@ 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 REDACTED_PLACEHOLDER = "<redacted>";
 const KEEP_PREFIX = `$1${REDACTED_PLACEHOLDER}`;
 const KNOWN_SECRET_RULES = [
@@ -71288,7 +71685,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++) {
@@ -71296,8 +71693,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 ?? ""
@@ -71317,7 +71714,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) => {
 	if (!stdout) return [];
 	const jsonStart = stdout.indexOf("{");
 	const sanitizedStdout = jsonStart > 0 ? stdout.slice(jsonStart) : stdout;
@@ -71334,8 +71731,10 @@ 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 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;
@@ -71348,7 +71747,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);
@@ -71357,27 +71756,30 @@ 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.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;
@@ -71390,8 +71792,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,
@@ -71579,7 +71981,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, 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;
@@ -71599,7 +72005,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);
 			} catch (error) {
 				if (!isSplittableReactDoctorError(error)) throw error;
 				if (isPastDeadline()) {
@@ -71705,10 +72111,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;
@@ -71807,6 +72215,266 @@ 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 prepareHtmlLintSources = (rootDirectory, temporaryDirectory, candidateFiles) => {
+	const lintFiles = [];
+	const sourcePathByLintPath = /* @__PURE__ */ new Map();
+	const sizeByLintPath = /* @__PURE__ */ new Map();
+	const htmlSourcesDirectory = Path.join(temporaryDirectory, "html-sources");
+	let htmlFileIndex = 0;
+	let hasThreeModuleImport = false;
+	for (const candidateFile of candidateFiles) {
+		if (!HTML_FILE_PATTERN.test(candidateFile)) {
+			lintFiles.push(candidateFile);
+			continue;
+		}
+		const absoluteSourcePath = Path.isAbsolute(candidateFile) ? candidateFile : Path.resolve(rootDirectory, candidateFile);
+		const sourceBuffer = NFS.readFileSync(absoluteSourcePath);
+		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,
+		sizeByLintPath,
+		hasThreeModuleImport
+	};
+};
 /**
 * Atomically (re)writes the generated oxlintrc.json. Used twice in
 * the runner: once for the primary scan, once for the
@@ -71967,6 +72635,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();
@@ -71980,21 +72650,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");
@@ -72030,7 +72685,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 preparedHtmlSources = prepareHtmlLintSources(rootDirectory, configDirectory, candidateFiles);
+		const lintFiles = preparedHtmlSources.lintFiles;
+		const hasHtmlFiles = preparedHtmlSources.sourcePathByLintPath.size > 0;
+		const lintProject = !project.hasThree && preparedHtmlSources.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 preparedHtmlSources.sizeByLintPath) sizeByFile.set(lintPath, sizeBytes);
 		const buildFileBatches = (passBaseArgs, passFiles) => sizeByFile !== null ? planLintBatches({
 			baseArgs: passBaseArgs,
 			files: passFiles,
@@ -72059,7 +72743,8 @@ const runOxlint = async (options) => {
 					fileBatches: passFileBatches,
 					rootDirectory,
 					nodeBinaryPath,
-					project,
+					project: lintProject,
+					sourcePathByLintPath: preparedHtmlSources.sourcePathByLintPath,
 					onPartialFailure: reportPartialFailure,
 					onAnalyzedFiles: (filePaths) => {
 						analyzedFiles = filePaths;
@@ -72094,7 +72779,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 && !hasHtmlFiles) {
 			const rulesetHash = computeRulesetHash({
 				config: buildConfig({
 					extendsPaths: [],
@@ -72252,14 +72937,15 @@ 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: preparedHtmlSources.sourcePathByLintPath,
 			onPartialFailure,
 			onAnalyzedFiles: (filePaths) => {
 				analyzedFiles = filePaths;
@@ -73835,7 +74521,8 @@ const SCANNABLE_EXTENSIONS = [
 	".js",
 	".jsx",
 	".mts",
-	".mjs"
+	".mjs",
+	".html"
 ];
 const SILENT_LOGGER = {
 	info: () => {},
@@ -75823,5 +76510,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]="3e0d8192-41dd-5226-8de2-b76eaf077e6c")}catch(e){}}();
-//# debugId=3e0d8192-41dd-5226-8de2-b76eaf077e6c
+!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]="c9dabb64-11c9-5783-a682-d985b8bc43fe")}catch(e){}}();
+//# debugId=c9dabb64-11c9-5783-a682-d985b8bc43fe