webpack 5.69.1 → 5.72.0

package/lib/NormalModule.js

@@ -50,6 +50,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
 /** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compiler")} Compiler */
@@ -194,6 +195,25 @@ makeSerializable(
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
+/**
+ * @typedef {Object} NormalModuleCreateData
+ * @property {string=} layer an optional layer in which the module is
+ * @property {string} type module type
+ * @property {string} request request string
+ * @property {string} userRequest request intended by user (without loaders from config)
+ * @property {string} rawRequest request without resolving
+ * @property {LoaderItem[]} loaders list of loaders
+ * @property {string} resource path + query of the real resource
+ * @property {Record<string, any>=} resourceResolveData resource resolve data
+ * @property {string} context context directory for resolving
+ * @property {string=} matchResource path + query of the matched resource (virtual)
+ * @property {Parser} parser the parser used
+ * @property {Record<string, any>=} parserOptions the options of the parser used
+ * @property {Generator} generator the generator used
+ * @property {Record<string, any>=} generatorOptions the options of the generator used
+ * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
+ */
+
 /** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -246,22 +266,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.layer an optional layer in which the module is
-	 * @param {string} options.type module type
-	 * @param {string} options.request request string
-	 * @param {string} options.userRequest request intended by user (without loaders from config)
-	 * @param {string} options.rawRequest request without resolving
-	 * @param {LoaderItem[]} options.loaders list of loaders
-	 * @param {string} options.resource path + query of the real resource
-	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
-	 * @param {string} options.context context directory for resolving
-	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
-	 * @param {Parser} options.parser the parser used
-	 * @param {object} options.parserOptions the options of the parser used
-	 * @param {Generator} options.generator the generator used
-	 * @param {object} options.generatorOptions the options of the generator used
-	 * @param {Object} options.resolveOptions options used for resolving requests from this module
+	 * @param {NormalModuleCreateData} options options object
 	 */
 	constructor({
 		layer,
@@ -370,7 +375,7 @@ class NormalModule extends Module {
 	nameForCondition() {
 		const resource = this.matchResource || this.resource;
 		const idx = resource.indexOf("?");
-		if (idx >= 0) return resource.substr(0, idx);
+		if (idx >= 0) return resource.slice(0, idx);
 		return resource;
 	}
 
@@ -553,7 +558,7 @@ class NormalModule extends Module {
 				let { options } = loader;
 
 				if (typeof options === "string") {
-					if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
+					if (options.startsWith("{") && options.endsWith("}")) {
 						try {
 							options = parseJson(options);
 						} catch (e) {
@@ -1171,7 +1176,8 @@ class NormalModule extends Module {
 		chunkGraph,
 		runtime,
 		concatenationScope,
-		codeGenerationResults
+		codeGenerationResults,
+		sourceTypes
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
@@ -1190,7 +1196,7 @@ class NormalModule extends Module {
 		};
 
 		const sources = new Map();
-		for (const type of this.generator.getTypes(this)) {
+		for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
 			const source = this.error
 				? new RawSource(
 						"throw new Error(" + JSON.stringify(this.error.message) + ");"

package/lib/NormalModuleFactory.js

@@ -34,14 +34,19 @@ const {
 } = require("./util/identifier");
 
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./Generator")} Generator */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
+/** @typedef {Pick<RuleSetRule, 'type'|'sideEffects'|'parser'|'generator'|'resolve'|'layer'>} ModuleSettings */
+/** @typedef {Partial<NormalModuleCreateData & {settings: ModuleSettings}>} CreateData */
+
 /**
  * @typedef {Object} ResolveData
  * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
@@ -51,7 +56,7 @@ const {
  * @property {Record<string, any> | undefined} assertions
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
- * @property {Object} createData
+ * @property {CreateData} createData
  * @property {LazySet<string>} fileDependencies
  * @property {LazySet<string>} missingDependencies
  * @property {LazySet<string>} contextDependencies
@@ -199,7 +204,7 @@ class NormalModuleFactory extends ModuleFactory {
 	}) {
 		super();
 		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
 			resolve: new AsyncSeriesBailHook(["resolveData"]),
 			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
 			resolveForScheme: new HookMap(
@@ -209,15 +214,15 @@ class NormalModuleFactory extends ModuleFactory {
 			resolveInScheme: new HookMap(
 				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
 			),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
 			factorize: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], TODO>} */
+			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
 			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
@@ -301,7 +306,9 @@ class NormalModuleFactory extends ModuleFactory {
 										return callback(new Error("Empty dependency (no request)"));
 									}
 
-									createdModule = new NormalModule(createData);
+									createdModule = new NormalModule(
+										/** @type {NormalModuleCreateData} */ (createData)
+									);
 								}
 
 								createdModule = this.hooks.module.call(
@@ -372,7 +379,7 @@ class NormalModuleFactory extends ModuleFactory {
 							resource: matchResource,
 							...cacheParseResource(matchResource)
 						};
-						requestWithoutMatchResource = request.substr(
+						requestWithoutMatchResource = request.slice(
 							matchResourceMatch[0].length
 						);
 					}
@@ -430,7 +437,7 @@ class NormalModuleFactory extends ModuleFactory {
 					try {
 						for (const item of loaders) {
 							if (typeof item.options === "string" && item.options[0] === "?") {
-								const ident = item.options.substr(1);
+								const ident = item.options.slice(1);
 								if (ident === "[[missing ident]]") {
 									throw new Error(
 										"No ident is provided by referenced loader. " +

package/lib/ProgressPlugin.js

@@ -531,15 +531,14 @@ class ProgressPlugin {
 			}
 		});
 		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
-		compiler.hooks.initialize.intercept({
+		compiler.hooks.beforeRun.intercept({
 			name: "ProgressPlugin",
 			call() {
 				handler(0, "");
 			}
 		});
-		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
-		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
-		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
+		interceptHook(compiler.hooks.beforeRun, 0.01, "setup", "before run");
+		interceptHook(compiler.hooks.run, 0.02, "setup", "run");
 		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
 		interceptHook(
 			compiler.hooks.normalModuleFactory,

package/lib/RuntimePlugin.js

@@ -11,6 +11,7 @@ const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirement
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 const AsyncModuleRuntimeModule = require("./runtime/AsyncModuleRuntimeModule");
 const AutoPublicPathRuntimeModule = require("./runtime/AutoPublicPathRuntimeModule");
+const BaseUriRuntimeModule = require("./runtime/BaseUriRuntimeModule");
 const CompatGetDefaultExportRuntimeModule = require("./runtime/CompatGetDefaultExportRuntimeModule");
 const CompatRuntimeModule = require("./runtime/CompatRuntimeModule");
 const CreateFakeNamespaceObjectRuntimeModule = require("./runtime/CreateFakeNamespaceObjectRuntimeModule");
@@ -96,6 +97,15 @@ class RuntimePlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("RuntimePlugin", compilation => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			const isChunkLoadingDisabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === false;
+			};
 			compilation.dependencyTemplates.set(
 				RuntimeRequirementsDependency,
 				new RuntimeRequirementsDependency.Template()
@@ -413,6 +423,14 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.baseURI)
+				.tap("RuntimePlugin", chunk => {
+					if (isChunkLoadingDisabledForChunk(chunk)) {
+						compilation.addRuntimeModule(chunk, new BaseUriRuntimeModule());
+						return true;
+					}
+				});
 			// TODO webpack 6: remove CompatRuntimeModule
 			compilation.hooks.additionalTreeRuntimeRequirements.tap(
 				"RuntimePlugin",

package/lib/RuntimeTemplate.js

@@ -83,6 +83,7 @@ class RuntimeTemplate {
 		this.outputOptions = outputOptions || {};
 		this.requestShortener = requestShortener;
 		this.globalObject = getGlobalObject(outputOptions.globalObject);
+		this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength);
 	}
 
 	isIIFE() {

package/lib/WebpackOptionsApply.js

@@ -35,6 +35,7 @@ const ResolverCachePlugin = require("./cache/ResolverCachePlugin");
 
 const CommonJsPlugin = require("./dependencies/CommonJsPlugin");
 const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin");
+const ImportMetaContextPlugin = require("./dependencies/ImportMetaContextPlugin");
 const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin");
 const ImportPlugin = require("./dependencies/ImportPlugin");
 const LoaderPlugin = require("./dependencies/LoaderPlugin");
@@ -361,6 +362,7 @@ class WebpackOptionsApply extends OptionsApply {
 		new RequireEnsurePlugin().apply(compiler);
 		new RequireContextPlugin().apply(compiler);
 		new ImportPlugin().apply(compiler);
+		new ImportMetaContextPlugin().apply(compiler);
 		new SystemPlugin().apply(compiler);
 		new ImportMetaPlugin().apply(compiler);
 		new URLPlugin().apply(compiler);

package/lib/asset/AssetGenerator.js

@@ -8,6 +8,7 @@
 const mimeTypes = require("mime-types");
 const path = require("path");
 const { RawSource } = require("webpack-sources");
+const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const createHash = require("../util/createHash");
@@ -23,6 +24,7 @@ const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
@@ -113,6 +115,7 @@ const decodeDataUriContent = (encoding, content) => {
 
 const JS_TYPES = new Set(["javascript"]);
 const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
+const DEFAULT_ENCODING = "base64";
 
 class AssetGenerator extends Generator {
 	/**
@@ -131,6 +134,74 @@ class AssetGenerator extends Generator {
 		this.emit = emit;
 	}
 
+	/**
+	 * @param {NormalModule} module module
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @returns {string} source file name
+	 */
+	getSourceFileName(module, runtimeTemplate) {
+		return makePathsRelative(
+			runtimeTemplate.compilation.compiler.context,
+			module.matchResource || module.resource,
+			runtimeTemplate.compilation.compiler.root
+		).replace(/^\.\//, "");
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
+	}
+
+	/**
+	 * @param {NormalModule} module module
+	 * @returns {string} mime type
+	 */
+	getMimeType(module) {
+		if (typeof this.dataUrlOptions === "function") {
+			throw new Error(
+				"This method must not be called when dataUrlOptions is a function"
+			);
+		}
+
+		let mimeType = this.dataUrlOptions.mimetype;
+		if (mimeType === undefined) {
+			const ext = path.extname(module.nameForCondition());
+			if (
+				module.resourceResolveData &&
+				module.resourceResolveData.mimetype !== undefined
+			) {
+				mimeType =
+					module.resourceResolveData.mimetype +
+					module.resourceResolveData.parameters;
+			} else if (ext) {
+				mimeType = mimeTypes.lookup(ext);
+
+				if (typeof mimeType !== "string") {
+					throw new Error(
+						"DataUrl can't be generated automatically, " +
+							`because there is no mimetype for "${ext}" in mimetype database. ` +
+							'Either pass a mimetype via "generator.mimetype" or ' +
+							'use type: "asset/resource" to create a resource file instead of a DataUrl'
+					);
+				}
+			}
+		}
+
+		if (typeof mimeType !== "string") {
+			throw new Error(
+				"DataUrl can't be generated automatically. " +
+					'Either pass a mimetype via "generator.mimetype" or ' +
+					'use type: "asset/resource" to create a resource file instead of a DataUrl'
+			);
+		}
+
+		return mimeType;
+	}
+
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
@@ -138,14 +209,21 @@ class AssetGenerator extends Generator {
 	 */
 	generate(
 		module,
-		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
+		{
+			runtime,
+			concatenationScope,
+			chunkGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			type,
+			getData
+		}
 	) {
 		switch (type) {
 			case "asset":
 				return module.originalSource();
 			default: {
-				runtimeRequirements.add(RuntimeGlobals.module);
-
+				let content;
 				const originalSource = module.originalSource();
 				if (module.buildInfo.dataUrl) {
 					let encodedSource;
@@ -170,31 +248,9 @@ class AssetGenerator extends Generator {
 							}
 						}
 						if (encoding === undefined) {
-							encoding = "base64";
-						}
-						let ext;
-						let mimeType = this.dataUrlOptions.mimetype;
-						if (mimeType === undefined) {
-							ext = path.extname(module.nameForCondition());
-							if (
-								module.resourceResolveData &&
-								module.resourceResolveData.mimetype !== undefined
-							) {
-								mimeType =
-									module.resourceResolveData.mimetype +
-									module.resourceResolveData.parameters;
-							} else if (ext) {
-								mimeType = mimeTypes.lookup(ext);
-							}
-						}
-						if (typeof mimeType !== "string") {
-							throw new Error(
-								"DataUrl can't be generated automatically, " +
-									`because there is no mimetype for "${ext}" in mimetype database. ` +
-									'Either pass a mimetype via "generator.mimetype" or ' +
-									'use type: "asset/resource" to create a resource file instead of a DataUrl'
-							);
+							encoding = DEFAULT_ENCODING;
 						}
+						const mimeType = this.getMimeType(module);
 
 						let encodedContent;
 
@@ -217,11 +273,7 @@ class AssetGenerator extends Generator {
 					}
 					const data = getData();
 					data.set("url", Buffer.from(encodedSource));
-					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${JSON.stringify(
-							encodedSource
-						)};`
-					);
+					content = JSON.stringify(encodedSource);
 				} else {
 					const assetModuleFilename =
 						this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
@@ -238,11 +290,10 @@ class AssetGenerator extends Generator {
 						runtimeTemplate.outputOptions.hashDigestLength
 					);
 					module.buildInfo.fullContentHash = fullHash;
-					const sourceFilename = makePathsRelative(
-						runtimeTemplate.compilation.compiler.context,
-						module.matchResource || module.resource,
-						runtimeTemplate.compilation.compiler.root
-					).replace(/^\.\//, "");
+					const sourceFilename = this.getSourceFileName(
+						module,
+						runtimeTemplate
+					);
 					let { path: filename, info: assetInfo } =
 						runtimeTemplate.compilation.getAssetPathWithInfo(
 							assetModuleFilename,
@@ -306,9 +357,22 @@ class AssetGenerator extends Generator {
 						data.set("filename", filename);
 						data.set("assetInfo", assetInfo);
 					}
+					content = assetPath;
+				}
 
+				if (concatenationScope) {
+					concatenationScope.registerNamespaceExport(
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					);
+					return new RawSource(
+						`${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+							ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+						} = ${content};`
+					);
+				} else {
+					runtimeRequirements.add(RuntimeGlobals.module);
 					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${assetPath};`
+						`${RuntimeGlobals.module}.exports = ${content};`
 					);
 				}
 			}
@@ -368,8 +432,59 @@ class AssetGenerator extends Generator {
 	 * @param {Hash} hash hash that will be modified
 	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
-	updateHash(hash, { module }) {
-		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
+	updateHash(hash, { module, runtime, runtimeTemplate, chunkGraph }) {
+		if (module.buildInfo.dataUrl) {
+			hash.update("data-url");
+			// this.dataUrlOptions as function should be pure and only depend on input source and filename
+			// therefore it doesn't need to be hashed
+			if (typeof this.dataUrlOptions === "function") {
+				const ident = /** @type {{ ident?: string }} */ (this.dataUrlOptions)
+					.ident;
+				if (ident) hash.update(ident);
+			} else {
+				if (
+					this.dataUrlOptions.encoding &&
+					this.dataUrlOptions.encoding !== DEFAULT_ENCODING
+				) {
+					hash.update(this.dataUrlOptions.encoding);
+				}
+				if (this.dataUrlOptions.mimetype)
+					hash.update(this.dataUrlOptions.mimetype);
+				// computed mimetype depends only on module filename which is already part of the hash
+			}
+		} else {
+			hash.update("resource");
+
+			const pathData = {
+				module,
+				runtime,
+				filename: this.getSourceFileName(module, runtimeTemplate),
+				chunkGraph,
+				contentHash: runtimeTemplate.contentHashReplacement
+			};
+
+			if (typeof this.publicPath === "function") {
+				hash.update("path");
+				const assetInfo = {};
+				hash.update(this.publicPath(pathData, assetInfo));
+				hash.update(JSON.stringify(assetInfo));
+			} else if (this.publicPath) {
+				hash.update("path");
+				hash.update(this.publicPath);
+			} else {
+				hash.update("no-path");
+			}
+
+			const assetModuleFilename =
+				this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+			const { path: filename, info } =
+				runtimeTemplate.compilation.getAssetPathWithInfo(
+					assetModuleFilename,
+					pathData
+				);
+			hash.update(filename);
+			hash.update(JSON.stringify(info));
+		}
 	}
 }
 

package/lib/asset/AssetParser.js

@@ -31,6 +31,7 @@ class AssetParser extends Parser {
 		}
 		state.module.buildInfo.strict = true;
 		state.module.buildMeta.exportsType = "default";
+		state.module.buildMeta.defaultObject = false;
 
 		if (typeof this.dataUrlCondition === "function") {
 			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {

package/lib/asset/AssetSourceGenerator.js

@@ -6,11 +6,13 @@
 "use strict";
 
 const { RawSource } = require("webpack-sources");
+const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../NormalModule")} NormalModule */
 
 const TYPES = new Set(["javascript"]);
@@ -21,9 +23,10 @@ class AssetSourceGenerator extends Generator {
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source} generated code
 	 */
-	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.module);
-
+	generate(
+		module,
+		{ concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements }
+	) {
 		const originalSource = module.originalSource();
 
 		if (!originalSource) {
@@ -38,9 +41,31 @@ class AssetSourceGenerator extends Generator {
 		} else {
 			encodedSource = content.toString("utf-8");
 		}
-		return new RawSource(
-			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
-		);
+
+		let sourceContent;
+		if (concatenationScope) {
+			concatenationScope.registerNamespaceExport(
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			);
+			sourceContent = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			} = ${JSON.stringify(encodedSource)};`;
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			sourceContent = `${RuntimeGlobals.module}.exports = ${JSON.stringify(
+				encodedSource
+			)};`;
+		}
+		return new RawSource(sourceContent);
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
 	}
 
 	/**

package/lib/asset/AssetSourceParser.js

@@ -23,6 +23,7 @@ class AssetSourceParser extends Parser {
 		const { module } = state;
 		module.buildInfo.strict = true;
 		module.buildMeta.exportsType = "default";
+		state.module.buildMeta.defaultObject = false;
 
 		return state;
 	}

package/lib/cache/PackFileCacheStrategy.js

@@ -639,10 +639,14 @@ class PackContentItems {
 				} catch (e) {
 					rollback(s);
 					if (e === NOT_SERIALIZABLE) continue;
-					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
-					);
-					logger.debug(e.stack);
+					const msg = "Skipped not serializable cache item";
+					if (e.message.includes("ModuleBuildError")) {
+						logger.log(`${msg} (in build error): ${e.message}`);
+						logger.debug(`${msg} '${key}' (in build error): ${e.stack}`);
+					} else {
+						logger.warn(`${msg}: ${e.message}`);
+						logger.debug(`${msg} '${key}': ${e.stack}`);
+					}
 				}
 			}
 			write(null);