webpack 5.104.1 → 5.105.0

package/lib/config/defaults.js

@@ -39,6 +39,7 @@ const {
 
 /** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptionsNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").Context} Context */
+/** @typedef {import("../../declarations/WebpackOptions").DevTool} Devtool */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
 /** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
 /** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
@@ -72,6 +73,8 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/EnableChunkLoadingPlugin").ChunkLoadingTypes} ChunkLoadingTypes */
+/** @typedef {import("../wasm/EnableWasmLoadingPlugin").WasmLoadingTypes} WasmLoadingTypes */
 /** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
 /** @typedef {import("./target").TargetProperties} TargetProperties */
 
@@ -90,14 +93,14 @@ const {
  * hotUpdateChunkFilename: NonNullable<Output["hotUpdateChunkFilename"]>,
  * hotUpdateGlobal: NonNullable<Output["hotUpdateGlobal"]>,
  * assetModuleFilename: NonNullable<Output["assetModuleFilename"]>,
- * webassemblyModuleFilename: NonNullable<Output["webassemblyModuleFilename"]>
+ * webassemblyModuleFilename: NonNullable<Output["webassemblyModuleFilename"]>,
  * sourceMapFilename: NonNullable<Output["sourceMapFilename"]>,
  * hotUpdateMainFilename: NonNullable<Output["hotUpdateMainFilename"]>,
  * devtoolNamespace: NonNullable<Output["devtoolNamespace"]>,
- * publicPath: NonNullable<Output["publicPath"]>
- * workerPublicPath: NonNullable<Output["workerPublicPath"]>
- * workerWasmLoading: NonNullable<Output["workerWasmLoading"]>
- * workerChunkLoading: NonNullable<Output["workerChunkLoading"]>
+ * publicPath: NonNullable<Output["publicPath"]>,
+ * workerPublicPath: NonNullable<Output["workerPublicPath"]>,
+ * workerWasmLoading: NonNullable<Output["workerWasmLoading"]>,
+ * workerChunkLoading: NonNullable<Output["workerChunkLoading"]>,
  * chunkFormat: NonNullable<Output["chunkFormat"]>,
  * module: NonNullable<Output["module"]>,
  * asyncChunks: NonNullable<Output["asyncChunks"]>,
@@ -187,31 +190,11 @@ const {
  */
 
 /**
- * @typedef {WebpackOptionsNormalized
- * & { context: NonNullable<WebpackOptionsNormalized["context"]> }
- * & { infrastructureLogging: InfrastructureLoggingNormalizedWithDefaults }
- * } WebpackOptionsNormalizedWithBaseDefaults
+ * @typedef {WebpackOptionsNormalized & { context: NonNullable<WebpackOptionsNormalized["context"]> } & { infrastructureLogging: InfrastructureLoggingNormalizedWithDefaults }} WebpackOptionsNormalizedWithBaseDefaults
  */
 
 /**
- * @typedef {WebpackOptionsNormalizedWithBaseDefaults
- * & { target: NonNullable<WebpackOptionsNormalized["target"]> }
- * & { output: OutputNormalizedWithDefaults }
- * & { optimization: OptimizationNormalizedWithDefaults }
- * & { devtool: NonNullable<WebpackOptionsNormalized["devtool"]> }
- * & { stats: NonNullable<WebpackOptionsNormalized["stats"]>  }
- * & { node: NonNullable<WebpackOptionsNormalized["node"]> }
- * & { profile: NonNullable<WebpackOptionsNormalized["profile"]> }
- * & { parallelism: NonNullable<WebpackOptionsNormalized["parallelism"]> }
- * & { snapshot: SnapshotNormalizedWithDefaults }
- * & { externalsPresets: ExternalsPresetsNormalizedWithDefaults }
- * & { externalsType: NonNullable<WebpackOptionsNormalized["externalsType"]> }
- * & { watch: NonNullable<WebpackOptionsNormalized["watch"]> }
- * & { performance: NonNullable<WebpackOptionsNormalized["performance"]> }
- * & { recordsInputPath: NonNullable<WebpackOptionsNormalized["recordsInputPath"]> }
- * & { recordsOutputPath: NonNullable<WebpackOptionsNormalized["recordsOutputPath"]>
- * & { dotenv: NonNullable<WebpackOptionsNormalized["dotenv"]> }
- * }} WebpackOptionsNormalizedWithDefaults
+ * @typedef {WebpackOptionsNormalizedWithBaseDefaults & { target: NonNullable<WebpackOptionsNormalized["target"]> } & { output: OutputNormalizedWithDefaults } & { optimization: OptimizationNormalizedWithDefaults } & { devtool: NonNullable<WebpackOptionsNormalized["devtool"]> } & { stats: NonNullable<WebpackOptionsNormalized["stats"]> } & { node: NonNullable<WebpackOptionsNormalized["node"]> } & { profile: NonNullable<WebpackOptionsNormalized["profile"]> } & { parallelism: NonNullable<WebpackOptionsNormalized["parallelism"]> } & { snapshot: SnapshotNormalizedWithDefaults } & { externalsPresets: ExternalsPresetsNormalizedWithDefaults } & { externalsType: NonNullable<WebpackOptionsNormalized["externalsType"]> } & { watch: NonNullable<WebpackOptionsNormalized["watch"]> } & { performance: NonNullable<WebpackOptionsNormalized["performance"]> } & { recordsInputPath: NonNullable<WebpackOptionsNormalized["recordsInputPath"]> } & { recordsOutputPath: NonNullable<WebpackOptionsNormalized["recordsOutputPath"]> } & { dotenv: NonNullable<WebpackOptionsNormalized["dotenv"]> }} WebpackOptionsNormalizedWithDefaults
  */
 
 /**
@@ -342,7 +325,28 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		}
 	}
 
-	F(options, "devtool", () => (development ? "eval" : false));
+	F(
+		options,
+		"devtool",
+		() =>
+			/** @type {Devtool} */ (
+				development
+					? [
+							options.experiments.css
+								? {
+										type: "css",
+										use: "source-map"
+									}
+								: undefined,
+							{
+								type: "javascript",
+								use: "eval"
+							}
+						].filter(Boolean)
+					: false
+			)
+	);
+
 	D(options, "watch", false);
 	D(options, "profile", false);
 	D(options, "parallelism", 100);
@@ -423,7 +427,10 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		isNode: targetProperties && targetProperties.node === true,
 		uniqueName: /** @type {string} */ (options.output.uniqueName),
 		targetProperties,
-		mode: options.mode
+		mode: options.mode,
+		outputModule:
+			/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
+			(options.output.module)
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -715,11 +722,12 @@ const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
  * @param {boolean} options.futureDefaults is future defaults enabled
  * @param {boolean} options.deferImport is defer import enabled
  * @param {boolean} options.isNode is node target platform
+ * @param {boolean} options.outputModule is output.module enabled
  * @returns {void}
  */
 const applyJavascriptParserOptionsDefaults = (
 	parserOptions,
-	{ futureDefaults, deferImport, isNode }
+	{ futureDefaults, deferImport, isNode, outputModule }
 ) => {
 	D(parserOptions, "unknownContextRequest", ".");
 	D(parserOptions, "unknownContextRegExp", false);
@@ -733,7 +741,7 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "wrappedContextRecursive", true);
 	D(parserOptions, "wrappedContextCritical", false);
 	D(parserOptions, "strictThisContextOnImports", false);
-	D(parserOptions, "importMeta", true);
+	D(parserOptions, "importMeta", outputModule ? "preserve-unknown" : true);
 	D(parserOptions, "dynamicImportMode", "lazy");
 	D(parserOptions, "dynamicImportPrefetch", false);
 	D(parserOptions, "dynamicImportPreload", false);
@@ -786,6 +794,7 @@ const applyCssGeneratorOptionsDefaults = (
  * @param {HashSalt} options.hashSalt hash salt
  * @param {HashDigest} options.hashDigest hash digest
  * @param {HashDigestLength} options.hashDigestLength hash digest length
+ * @param {boolean} options.outputModule is output.module enabled
  * @returns {void}
  */
 const applyModuleDefaults = (
@@ -803,7 +812,8 @@ const applyModuleDefaults = (
 		uniqueName,
 		targetProperties,
 		mode,
-		deferImport
+		deferImport,
+		outputModule
 	}
 ) => {
 	if (cache) {
@@ -862,7 +872,8 @@ const applyModuleDefaults = (
 		{
 			futureDefaults,
 			deferImport,
-			isNode
+			isNode,
+			outputModule
 		}
 	);
 
@@ -1443,9 +1454,7 @@ const applyOutputDefaults = (
 				throw new Error(
 					"For the selected environment is no default ESM chunk format available:\n" +
 						"ESM exports can be chosen when 'import()' is available.\n" +
-						`JSONP Array push can be chosen when 'document' is available.\n${
-							helpMessage
-						}`
+						`JSONP Array push can be chosen when 'document' is available.\n${helpMessage}`
 				);
 			} else {
 				if (tp.document) return "array-push";
@@ -1460,9 +1469,7 @@ const applyOutputDefaults = (
 								: ""
 						}\n` +
 						"JSONP Array push ('array-push') can be chosen when 'document' or 'importScripts' is available.\n" +
-						`CommonJs exports ('commonjs') can be chosen when 'require' or node builtins are available.\n${
-							helpMessage
-						}`
+						`CommonJs exports ('commonjs') can be chosen when 'require' or node builtins are available.\n${helpMessage}`
 				);
 			}
 		}
@@ -1588,7 +1595,7 @@ const applyOutputDefaults = (
 			"policyName",
 			() =>
 				/** @type {NonNullable<Output["uniqueName"]>} */
-				(output.uniqueName).replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
+				(output.uniqueName).replace(/[^a-z0-9\-#=_/@.%]+/gi, "_") || "webpack"
 		);
 		D(trustedTypes, "onPolicyCreationFailure", "stop");
 	}
@@ -1617,6 +1624,7 @@ const applyOutputDefaults = (
 	});
 
 	A(output, "enabledChunkLoadingTypes", () => {
+		/** @type {ChunkLoadingTypes} */
 		const enabledChunkLoadingTypes = new Set();
 		if (output.chunkLoading) {
 			enabledChunkLoadingTypes.add(output.chunkLoading);
@@ -1633,6 +1641,7 @@ const applyOutputDefaults = (
 	});
 
 	A(output, "enabledWasmLoadingTypes", () => {
+		/** @type {WasmLoadingTypes} */
 		const enabledWasmLoadingTypes = new Set();
 		if (output.wasmLoading) {
 			enabledWasmLoadingTypes.add(output.wasmLoading);
@@ -1957,6 +1966,20 @@ const getResolveDefaults = ({
 		extensions: [...jsExtensions]
 	});
 
+	/** @type {() => ResolveOptions} */
+	const workerDeps = () => {
+		const options = esmDeps();
+
+		const conditionNames = options.conditionNames
+			? ["worker", ...options.conditionNames]
+			: options.conditionNames;
+		return {
+			...options,
+			conditionNames,
+			preferRelative: true
+		};
+	};
+
 	/** @type {ResolveOptions} */
 	const resolveOptions = {
 		cache,
@@ -1976,10 +1999,7 @@ const getResolveDefaults = ({
 			url: {
 				preferRelative: true
 			},
-			worker: {
-				...esmDeps(),
-				preferRelative: true
-			},
+			worker: workerDeps(),
 			commonjs: cjsDeps(),
 			amd: cjsDeps(),
 			// for backward-compat: loadModule
@@ -1992,6 +2012,7 @@ const getResolveDefaults = ({
 	};
 
 	if (css) {
+		/** @type {string[]} */
 		const styleConditions = [];
 
 		styleConditions.push("webpack");

package/lib/config/normalization.js

@@ -24,6 +24,11 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../WebpackError")} WebpackError */
 
+/**
+ * @typedef {object} WebpackOptionsInterception
+ * @property {WebpackOptionsNormalized["devtool"]=} devtool
+ */
+
 const handledDeprecatedNoEmitOnErrors = util.deprecate(
 	/**
 	 * @param {boolean} noEmitOnErrors no emit on errors
@@ -582,4 +587,95 @@ const getNormalizedOptimizationRuntimeChunk = (runtimeChunk) => {
 	};
 };
 
+/**
+ * @param {WebpackOptionsNormalized} options options to be intercepted
+ * @returns {{ options: WebpackOptionsNormalized, interception?: WebpackOptionsInterception }} options and interception
+ */
+const applyWebpackOptionsInterception = (options) => {
+	// Return origin options when backCompat is disabled
+	if (options.experiments.futureDefaults) {
+		return {
+			options
+		};
+	}
+
+	// TODO webpack6 - remove compatibility logic and move `devtools` fully into `devtool` with multi-type support
+	let _devtool = options.devtool;
+	/** @type {WebpackOptionsNormalized["devtool"]} */
+	let cached;
+
+	const devtoolBackCompat = () => {
+		if (Array.isArray(_devtool)) {
+			if (cached) return cached;
+			// Prefer `all`, then `javascript`, then `css`
+			const match = ["all", "javascript", "css"]
+				.map((type) =>
+					/** @type {Extract<WebpackOptionsNormalized["devtool"], EXPECTED_ANY[]>} */ (
+						_devtool
+					).find((item) => item.type === type)
+				)
+				.find(Boolean);
+
+			// If `devtool: []` is specified, return `false` here
+			return (cached = match ? match.use : false);
+		}
+		return _devtool;
+	};
+
+	/** @type {ProxyHandler<WebpackOptionsNormalized>} */
+	const handler = Object.create(null);
+	handler.get = (target, prop, receiver) => {
+		if (prop === "devtool") {
+			return devtoolBackCompat();
+		}
+		return Reflect.get(target, prop, receiver);
+	};
+	handler.set = (target, prop, value, receiver) => {
+		if (prop === "devtool") {
+			_devtool = value;
+			cached = undefined;
+			return true;
+		}
+		return Reflect.set(target, prop, value, receiver);
+	};
+	handler.deleteProperty = (target, prop) => {
+		if (prop === "devtool") {
+			_devtool = undefined;
+			cached = undefined;
+			return true;
+		}
+		return Reflect.deleteProperty(target, prop);
+	};
+	handler.defineProperty = (target, prop, descriptor) => {
+		if (prop === "devtool") {
+			_devtool = descriptor.value;
+			cached = undefined;
+			return true;
+		}
+		return Reflect.defineProperty(target, prop, descriptor);
+	};
+	handler.getOwnPropertyDescriptor = (target, prop) => {
+		if (prop === "devtool") {
+			return {
+				configurable: true,
+				enumerable: true,
+				value: devtoolBackCompat(),
+				writable: true
+			};
+		}
+		return Reflect.getOwnPropertyDescriptor(target, prop);
+	};
+
+	return {
+		options: new Proxy(options, handler),
+		interception: {
+			get devtool() {
+				return _devtool;
+			}
+		}
+	};
+};
+
+module.exports.applyWebpackOptionsInterception =
+	applyWebpackOptionsInterception;
 module.exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;

package/lib/container/ContainerEntryModule.js

@@ -28,6 +28,7 @@ const ContainerExposedDependency = require("./ContainerExposedDependency");
 /** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
@@ -147,12 +148,14 @@ class ContainerEntryModule extends Module {
 	 * @returns {CodeGenerationResult} result
 	 */
 	codeGeneration({ moduleGraph, chunkGraph, runtimeTemplate }) {
+		/** @type {Sources} */
 		const sources = new Map();
 		const runtimeRequirements = new Set([
 			RuntimeGlobals.definePropertyGetters,
 			RuntimeGlobals.hasOwnProperty,
 			RuntimeGlobals.exports
 		]);
+		/** @type {string[]} */
 		const getters = [];
 
 		for (const block of this.blocks) {
@@ -167,6 +170,7 @@ class ContainerEntryModule extends Module {
 				};
 			});
 
+			/** @type {string} */
 			let str;
 
 			if (modules.some((m) => !m.module)) {

package/lib/container/FallbackModule.js

@@ -28,6 +28,7 @@ const FallbackItemDependency = require("./FallbackItemDependency");
 /** @typedef {import("../Module").NameForCondition} NameForCondition */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
@@ -158,6 +159,7 @@ class FallbackModule extends Module {
 			])};`,
 			"module.exports = loop();"
 		]);
+		/** @type {Sources} */
 		const sources = new Map();
 		sources.set(JAVASCRIPT_TYPE, new RawSource(code));
 		return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS };

package/lib/container/HoistContainerReferencesPlugin.js

@@ -34,7 +34,9 @@ class HoistContainerReferences {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const hooks =
 				getModuleFederationPlugin().getCompilationHooks(compilation);
+			/** @type {Set<Dependency>} */
 			const depsToTrace = new Set();
+			/** @type {Set<Dependency>} */
 			const entryExternalsToHoist = new Set();
 			hooks.addContainerEntryDependency.tap(PLUGIN_NAME, (dep) => {
 				depsToTrace.add(dep);
@@ -89,6 +91,7 @@ class HoistContainerReferences {
 			);
 
 			const containerRuntimes = chunkGraph.getModuleRuntimes(entryModule);
+			/** @type {Set<string>} */
 			const runtimes = new Set();
 
 			for (const runtimeSpec of containerRuntimes) {
@@ -136,6 +139,7 @@ class HoistContainerReferences {
 
 			const containerRuntimes =
 				chunkGraph.getModuleRuntimes(containerEntryModule);
+			/** @type {Set<string>} */
 			const runtimes = new Set();
 
 			for (const runtimeSpec of containerRuntimes) {
@@ -198,7 +202,9 @@ class HoistContainerReferences {
  */
 function getAllReferencedModules(compilation, module, type, includeInitial) {
 	const collectedModules = new Set(includeInitial ? [module] : []);
+	/** @type {WeakSet<Module>} */
 	const visitedModules = new WeakSet([module]);
+	/** @type {Module[]} */
 	const stack = [module];
 
 	while (stack.length > 0) {

package/lib/container/RemoteModule.js

@@ -18,13 +18,17 @@ const RemoteToExternalDependency = require("./RemoteToExternalDependency");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NameForCondition} NameForCondition */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module").ExportsType} ExportsType */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -128,6 +132,19 @@ class RemoteModule extends Module {
 		return REMOTE_AND_SHARE_INIT_TYPES;
 	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {boolean | undefined} strict the importing module is strict
+	 * @returns {ExportsType} export type
+	 * "namespace": Exports is already a namespace object. namespace = exports.
+	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 */
+	getExportsType(moduleGraph, strict) {
+		return "dynamic";
+	}
+
 	/**
 	 * @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path)
 	 */
@@ -142,8 +159,10 @@ class RemoteModule extends Module {
 	codeGeneration({ moduleGraph, chunkGraph }) {
 		const module = moduleGraph.getModule(this.dependencies[0]);
 		const id = module && chunkGraph.getModuleId(module);
+		/** @type {Sources} */
 		const sources = new Map();
 		sources.set("remote", new RawSource(""));
+		/** @type {CodeGenerationResultData} */
 		const data = new Map();
 		data.set("share-init", [
 			{

package/lib/css/CssGenerator.js

@@ -19,6 +19,7 @@ const {
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CssImportDependency = require("../dependencies/CssImportDependency");
+const EntryDependency = require("../dependencies/EntryDependency");
 const { getUndoPath } = require("../util/identifier");
 const memoize = require("../util/memoize");
 
@@ -362,6 +363,7 @@ class CssGenerator extends Generator {
 
 				if (generateContext.concatenationScope) {
 					const source = new ConcatSource();
+					/** @type {Set<string>} */
 					const usedIdentifiers = new Set();
 					const { RESERVED_IDENTIFIER } = getPropertyName();
 
@@ -413,6 +415,7 @@ class CssGenerator extends Generator {
 					);
 				}
 
+				/** @type {string[]} */
 				const exports = [];
 
 				for (const [name, v] of cssData.exports) {
@@ -465,13 +468,19 @@ class CssGenerator extends Generator {
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		if (this._generatesJsOnly(module)) {
-			return JAVASCRIPT_TYPES;
-		}
+		const exportType = /** @type {BuildMeta} */ (module.buildMeta).exportType;
 		const sourceTypes = new Set();
 		const connections = this._moduleGraph.getIncomingConnections(module);
+
+		let isEntryModule = false;
 		for (const connection of connections) {
-			if (connection.dependency instanceof CssImportDependency) {
+			if (connection.dependency instanceof EntryDependency) {
+				isEntryModule = true;
+			}
+			if (
+				exportType === "link" &&
+				connection.dependency instanceof CssImportDependency
+			) {
 				continue;
 			}
 			if (!connection.originModule) {
@@ -479,7 +488,25 @@ class CssGenerator extends Generator {
 			}
 			if (connection.originModule.type.split("/")[0] !== CSS_TYPE) {
 				sourceTypes.add(JAVASCRIPT_TYPE);
+			} else {
+				const originModule = /** @type {CssModule} */ connection.originModule;
+				const originExportType = /** @type {BuildMeta} */ (
+					originModule.buildMeta
+				).exportType;
+				if (
+					/** @type {boolean} */ (
+						originExportType && originExportType !== "link"
+					)
+				) {
+					sourceTypes.add(JAVASCRIPT_TYPE);
+				}
+			}
+		}
+		if (this._generatesJsOnly(module)) {
+			if (sourceTypes.has(JAVASCRIPT_TYPE) || isEntryModule) {
+				return JAVASCRIPT_TYPES;
 			}
+			return new Set();
 		}
 		if (sourceTypes.has(JAVASCRIPT_TYPE)) {
 			return JAVASCRIPT_AND_CSS_TYPES;