webpack 5.36.0 → 5.37.1

package/lib/buildChunkGraph.js

@@ -519,7 +519,8 @@ const visitModules = (
 			if (skipConnectionBuffer.length > 0) {
 				let { skippedModuleConnections } = chunkGroupInfo;
 				if (skippedModuleConnections === undefined) {
-					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections = new Set();
+					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections =
+						new Set();
 				}
 				for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
 					skippedModuleConnections.add(skipConnectionBuffer[i]);
@@ -695,7 +696,8 @@ const visitModules = (
 		let resultingAvailableModules;
 		if (minAvailableModules.size > minAvailableModules.plus.size) {
 			// resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
-			resultingAvailableModules = /** @type {Set<Module> & {plus: Set<Module>}} */ (new Set());
+			resultingAvailableModules =
+				/** @type {Set<Module> & {plus: Set<Module>}} */ (new Set());
 			for (const module of minAvailableModules.plus)
 				minAvailableModules.add(module);
 			minAvailableModules.plus = EMPTY_SET;
@@ -703,9 +705,10 @@ const visitModules = (
 			chunkGroupInfo.minAvailableModulesOwned = false;
 		} else {
 			// resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
-			resultingAvailableModules = /** @type {Set<Module> & {plus: Set<Module>}} */ (new Set(
-				minAvailableModules
-			));
+			resultingAvailableModules =
+				/** @type {Set<Module> & {plus: Set<Module>}} */ (
+					new Set(minAvailableModules)
+				);
 			resultingAvailableModules.plus = minAvailableModules.plus;
 		}
 
@@ -715,7 +718,8 @@ const visitModules = (
 				resultingAvailableModules.add(m);
 			}
 		}
-		return (chunkGroupInfo.resultingAvailableModules = resultingAvailableModules);
+		return (chunkGroupInfo.resultingAvailableModules =
+			resultingAvailableModules);
 	};
 
 	const processConnectQueue = () => {
@@ -732,9 +736,8 @@ const visitModules = (
 			}
 
 			// 2. Calculate resulting available modules
-			const resultingAvailableModules = calculateResultingAvailableModules(
-				chunkGroupInfo
-			);
+			const resultingAvailableModules =
+				calculateResultingAvailableModules(chunkGroupInfo);
 
 			const runtime = chunkGroupInfo.runtime;
 
@@ -800,9 +803,8 @@ const visitModules = (
 								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
 									// We can't remove modules from the plus part
 									// so we need to merge plus into the normal part to allow modifying it
-									const iterator = cachedMinAvailableModules.plus[
-										Symbol.iterator
-									]();
+									const iterator =
+										cachedMinAvailableModules.plus[Symbol.iterator]();
 									// fast forward add all modules until m
 									/** @type {IteratorResult<Module>} */
 									let it;
@@ -951,13 +953,12 @@ const visitModules = (
 								statForkedMergedModulesCountPlus += availableModules.plus.size;
 								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
 								// we already know that all modules directly from cachedMinAvailableModules are in availableModules too
-								const newSet = /** @type {ModuleSetPlus} */ (new Set(
-									cachedMinAvailableModules
-								));
+								const newSet = /** @type {ModuleSetPlus} */ (
+									new Set(cachedMinAvailableModules)
+								);
 								newSet.plus = EMPTY_SET;
-								const iterator = cachedMinAvailableModules.plus[
-									Symbol.iterator
-								]();
+								const iterator =
+									cachedMinAvailableModules.plus[Symbol.iterator]();
 								// fast forward add all modules until m
 								/** @type {IteratorResult<Module>} */
 								let it;
@@ -997,10 +998,15 @@ const visitModules = (
 	};
 
 	const processChunkGroupsForCombining = () => {
-		loop: for (const info of chunkGroupsForCombining) {
+		for (const info of chunkGroupsForCombining) {
 			for (const source of info.availableSources) {
-				if (!source.minAvailableModules) continue loop;
+				if (!source.minAvailableModules) {
+					chunkGroupsForCombining.delete(info);
+					break;
+				}
 			}
+		}
+		for (const info of chunkGroupsForCombining) {
 			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
 			availableModules.plus = EMPTY_SET;
 			const mergeSet = set => {
@@ -1013,9 +1019,8 @@ const visitModules = (
 			};
 			// combine minAvailableModules from all resultingAvailableModules
 			for (const source of info.availableSources) {
-				const resultingAvailableModules = calculateResultingAvailableModules(
-					source
-				);
+				const resultingAvailableModules =
+					calculateResultingAvailableModules(source);
 				mergeSet(resultingAvailableModules);
 				mergeSet(resultingAvailableModules.plus);
 			}

package/lib/cache/PackFileCacheStrategy.js

@@ -561,7 +561,40 @@ class PackContentItems {
 		this.map = map;
 	}
 
-	serialize({ write, snapshot, rollback, logger }) {
+	serialize({ write, snapshot, rollback, logger, profile }) {
+		if (profile) {
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					const start = process.hrtime();
+					write(value);
+					const durationHr = process.hrtime(start);
+					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+					if (duration > 1) {
+						if (duration > 500)
+							logger.error(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 50)
+							logger.warn(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 10)
+							logger.info(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 5)
+							logger.log(`Serialization of '${key}': ${duration} ms`);
+						else logger.debug(`Serialization of '${key}': ${duration} ms`);
+					}
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
+					);
+					logger.debug(e.stack);
+				}
+			}
+			write(null);
+			return;
+		}
 		// Try to serialize all at once
 		const s = snapshot();
 		try {
@@ -590,9 +623,32 @@ class PackContentItems {
 		}
 	}
 
-	deserialize({ read }) {
+	deserialize({ read, logger, profile }) {
 		if (read()) {
 			this.map = read();
+		} else if (profile) {
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				const start = process.hrtime();
+				const value = read();
+				const durationHr = process.hrtime(start);
+				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+				if (duration > 1) {
+					if (duration > 100)
+						logger.error(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 20)
+						logger.warn(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 5)
+						logger.info(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 2)
+						logger.log(`Deserialization of '${key}': ${duration} ms`);
+					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+				}
+				map.set(key, value);
+				key = read();
+			}
+			this.map = map;
 		} else {
 			const map = new Map();
 			let key = read();
@@ -787,6 +843,7 @@ class PackFileCacheStrategy {
 	 * @param {Logger} options.logger a logger
 	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
 	 * @param {number} options.maxAge max age of cache items
+	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
 	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
 	 */
 	constructor({
@@ -798,6 +855,7 @@ class PackFileCacheStrategy {
 		logger,
 		snapshot,
 		maxAge,
+		profile,
 		allowCollectingMemory
 	}) {
 		this.fileSerializer = createFileSerializer(fs);
@@ -812,6 +870,7 @@ class PackFileCacheStrategy {
 		this.version = version;
 		this.logger = logger;
 		this.maxAge = maxAge;
+		this.profile = profile;
 		this.allowCollectingMemory = allowCollectingMemory;
 		this.snapshot = snapshot;
 		/** @type {Set<string>} */
@@ -840,7 +899,7 @@ class PackFileCacheStrategy {
 	 * @returns {Promise<Pack>} the pack
 	 */
 	_openPack() {
-		const { logger, cacheLocation, version } = this;
+		const { logger, profile, cacheLocation, version } = this;
 		/** @type {Snapshot} */
 		let buildSnapshot;
 		/** @type {Set<string>} */
@@ -857,6 +916,7 @@ class PackFileCacheStrategy {
 				filename: `${cacheLocation}/index.pack`,
 				extension: ".pack",
 				logger,
+				profile,
 				retainedBuffer: this.allowCollectingMemory
 					? allowCollectingMemory
 					: undefined
@@ -981,7 +1041,8 @@ class PackFileCacheStrategy {
 					if (newBuildDependencies)
 						this.newBuildDependencies.addAll(newBuildDependencies);
 					this.resolveResults = resolveResults;
-					this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
+					this.resolveBuildDependenciesSnapshot =
+						resolveBuildDependenciesSnapshot;
 					return pack;
 				}
 				return new Pack(logger, this.maxAge);
@@ -1103,10 +1164,11 @@ class PackFileCacheStrategy {
 											);
 										}
 										if (this.resolveBuildDependenciesSnapshot) {
-											this.resolveBuildDependenciesSnapshot = this.fileSystemInfo.mergeSnapshots(
-												this.resolveBuildDependenciesSnapshot,
-												snapshot
-											);
+											this.resolveBuildDependenciesSnapshot =
+												this.fileSystemInfo.mergeSnapshots(
+													this.resolveBuildDependenciesSnapshot,
+													snapshot
+												);
 										} else {
 											this.resolveBuildDependenciesSnapshot = snapshot;
 										}
@@ -1134,10 +1196,11 @@ class PackFileCacheStrategy {
 												this.logger.debug("Captured build dependencies");
 
 												if (this.buildSnapshot) {
-													this.buildSnapshot = this.fileSystemInfo.mergeSnapshots(
-														this.buildSnapshot,
-														snapshot
-													);
+													this.buildSnapshot =
+														this.fileSystemInfo.mergeSnapshots(
+															this.buildSnapshot,
+															snapshot
+														);
 												} else {
 													this.buildSnapshot = snapshot;
 												}
@@ -1172,7 +1235,8 @@ class PackFileCacheStrategy {
 						.serialize(content, {
 							filename: `${this.cacheLocation}/index.pack`,
 							extension: ".pack",
-							logger: this.logger
+							logger: this.logger,
+							profile: this.profile
 						})
 						.then(() => {
 							for (const dep of newBuildDependencies) {

package/lib/config/defaults.js

@@ -293,6 +293,7 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 			);
 			D(cache, "hashAlgorithm", "md4");
 			D(cache, "store", "pack");
+			D(cache, "profile", false);
 			D(cache, "idleTimeout", 60000);
 			D(cache, "idleTimeoutForInitialStore", 0);
 			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
@@ -317,9 +318,10 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 const applySnapshotDefaults = (snapshot, { production }) => {
 	A(snapshot, "managedPaths", () => {
 		if (process.versions.pnp === "3") {
-			const match = /^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-				require.resolve("watchpack")
-			);
+			const match =
+				/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+					require.resolve("watchpack")
+				);
 			if (match) {
 				return [path.resolve(match[1], "unplugged")];
 			}
@@ -336,16 +338,18 @@ const applySnapshotDefaults = (snapshot, { production }) => {
 	});
 	A(snapshot, "immutablePaths", () => {
 		if (process.versions.pnp === "1") {
-			const match = /^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
-				require.resolve("watchpack")
-			);
+			const match =
+				/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+					require.resolve("watchpack")
+				);
 			if (match) {
 				return [match[1]];
 			}
 		} else if (process.versions.pnp === "3") {
-			const match = /^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-				require.resolve("watchpack")
-			);
+			const match =
+				/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+					require.resolve("watchpack")
+				);
 			if (match) {
 				return [match[1]];
 			}
@@ -731,6 +735,16 @@ const applyOutputDefaults = (
 	F(output.environment, "dynamicImport", () => tp && tp.dynamicImport);
 	F(output.environment, "module", () => tp && tp.module);
 
+	const { trustedTypes } = output;
+	if (trustedTypes) {
+		F(
+			trustedTypes,
+			"policyName",
+			() =>
+				output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
+		);
+	}
+
 	/**
 	 * @param {function(EntryDescription): void} fn iterator
 	 * @returns {void}
@@ -948,7 +962,7 @@ const applyOptimizationDefaults = (
 		A(splitChunks, "defaultSizeTypes", () => ["javascript", "unknown"]);
 		D(splitChunks, "hidePathInfo", production);
 		D(splitChunks, "chunks", "async");
-		D(splitChunks, "usedExports", true);
+		D(splitChunks, "usedExports", optimization.usedExports === true);
 		D(splitChunks, "minChunks", 1);
 		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
 		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));

package/lib/config/normalization.js

@@ -92,9 +92,9 @@ const keyedNestedConfig = (value, fn, customKeys) => {
 			? {}
 			: Object.keys(value).reduce(
 					(obj, key) => (
-						(obj[key] = (customKeys && key in customKeys
-							? customKeys[key]
-							: fn)(value[key])),
+						(obj[key] = (
+							customKeys && key in customKeys ? customKeys[key] : fn
+						)(value[key])),
 						obj
 					),
 					/** @type {Record<string, R>} */ ({})
@@ -131,6 +131,7 @@ const getNormalizedWebpackOptions = config => {
 						type: "filesystem",
 						maxMemoryGenerations: cache.maxMemoryGenerations,
 						maxAge: cache.maxAge,
+						profile: cache.profile,
 						buildDependencies: cloneObject(cache.buildDependencies),
 						cacheDirectory: cache.cacheDirectory,
 						cacheLocation: cache.cacheLocation,
@@ -162,10 +163,10 @@ const getNormalizedWebpackOptions = config => {
 			config.entry === undefined
 				? { main: {} }
 				: typeof config.entry === "function"
-				? (fn => () =>
-						Promise.resolve().then(fn).then(getNormalizedEntryStatic))(
-						config.entry
-				  )
+				? (
+						fn => () =>
+							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
+				  )(config.entry)
 				: getNormalizedEntryStatic(config.entry),
 		experiments: cloneObject(config.experiments),
 		externals: config.externals,
@@ -337,6 +338,15 @@ const getNormalizedWebpackOptions = config => {
 				sourceMapFilename: output.sourceMapFilename,
 				sourcePrefix: output.sourcePrefix,
 				strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+				trustedTypes: optionalNestedConfig(
+					output.trustedTypes,
+					trustedTypes => {
+						if (trustedTypes === true) return {};
+						if (typeof trustedTypes === "string")
+							return { policyName: trustedTypes };
+						return { ...trustedTypes };
+					}
+				),
 				uniqueName: output.uniqueName,
 				wasmLoading: output.wasmLoading,
 				webassemblyModuleFilename: output.webassemblyModuleFilename,

package/lib/debug/ProfilingPlugin.js

@@ -332,9 +332,10 @@ const interceptAllParserHooks = (moduleFactory, tracer) => {
 const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
 	interceptAllHooksFor(
 		{
-			hooks: require("../javascript/JavascriptModulesPlugin").getCompilationHooks(
-				compilation
-			)
+			hooks:
+				require("../javascript/JavascriptModulesPlugin").getCompilationHooks(
+					compilation
+				)
 		},
 		tracer,
 		"JavascriptModulesPlugin"

package/lib/dependencies/AMDRequireDependency.js

@@ -77,9 +77,9 @@ AMDRequireDependency.Template = class AMDRequireDependencyTemplate extends (
 		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
 		const dep = /** @type {AMDRequireDependency} */ (dependency);
-		const depBlock = /** @type {AsyncDependenciesBlock} */ (moduleGraph.getParentBlock(
-			dep
-		));
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
 		const promise = runtimeTemplate.blockPromise({
 			chunkGraph,
 			block: depBlock,

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -230,9 +230,8 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 				if (name === "__esModule" && isNamespaceImport) {
 					exports.add(name);
 				} else if (importedExportsInfo) {
-					const importedExportInfo = importedExportsInfo.getReadOnlyExportInfo(
-						name
-					);
+					const importedExportInfo =
+						importedExportsInfo.getReadOnlyExportInfo(name);
 					if (importedExportInfo.provided === false) continue;
 					exports.add(name);
 					if (importedExportInfo.provided === true) continue;

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -192,7 +192,9 @@ class CommonJsExportsParserPlugin {
 		parser.hooks.call
 			.for("Object.defineProperty")
 			.tap("CommonJsExportsParserPlugin", expression => {
-				const expr = /** @type {import("estree").CallExpression} */ (expression);
+				const expr = /** @type {import("estree").CallExpression} */ (
+					expression
+				);
 				if (!parser.isStatementLevelExpression(expr)) return;
 				if (expr.arguments.length !== 3) return;
 				if (expr.arguments[0].type === "SpreadElement") return;

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -182,10 +182,8 @@ class CommonJsImportsParserPlugin {
 		};
 		const createRequireHandler = callNew => expr => {
 			if (options.commonjsMagicComments) {
-				const {
-					options: requireOptions,
-					errors: commentErrors
-				} = parser.parseCommentOptions(expr.range);
+				const { options: requireOptions, errors: commentErrors } =
+					parser.parseCommentOptions(expr.range);
 
 				if (commentErrors) {
 					for (const e of commentErrors) {

package/lib/dependencies/CommonJsPlugin.js

@@ -265,13 +265,14 @@ class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
 	generate() {
 		const { runtimeTemplate } = this.compilation;
 		return Template.asString([
-			`${
-				RuntimeGlobals.nodeModuleDecorator
-			} = ${runtimeTemplate.basicFunction("module", [
-				"module.paths = [];",
-				"if (!module.children) module.children = [];",
-				"return module;"
-			])};`
+			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
+				"module",
+				[
+					"module.paths = [];",
+					"if (!module.children) module.children = [];",
+					"return module;"
+				]
+			)};`
 		]);
 	}
 }

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -45,6 +45,7 @@ makeSerializable(
 	"webpack/lib/dependencies/CommonJsRequireContextDependency"
 );
 
-CommonJsRequireContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+CommonJsRequireContextDependency.Template =
+	ContextDependencyTemplateAsRequireCall;
 
 module.exports = CommonJsRequireContextDependency;

package/lib/dependencies/ContextDependencyHelpers.js

@@ -61,10 +61,11 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 
 		const valueRange = param.range;
 		const { context, prefix } = splitContextFromPrefix(prefixRaw);
-		const { path: postfix, query, fragment } = parseResource(
-			postfixRaw,
-			parser
-		);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
 
 		// When there are more than two quasis, the generated RegExp can be more precise
 		// We join the quasis with the expression regexp
@@ -160,10 +161,11 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 			param.postfix && param.postfix.isString() ? param.postfix.range : null;
 		const valueRange = param.range;
 		const { context, prefix } = splitContextFromPrefix(prefixRaw);
-		const { path: postfix, query, fragment } = parseResource(
-			postfixRaw,
-			parser
-		);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
 		const regExp = new RegExp(
 			`^${quoteMeta(prefix)}${options.wrappedContextRegExp.source}${quoteMeta(
 				postfix

package/lib/dependencies/CreateScriptUrlDependency.js

@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class CreateScriptUrlDependency extends NullDependency {
+	/**
+	 * @param {[number, number]} range range
+	 */
+	constructor(range) {
+		super();
+		this.range = range;
+	}
+
+	get type() {
+		return "create script url";
+	}
+}
+
+CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {CreateScriptUrlDependency} */ (dependency);
+
+		runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
+
+		source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
+		source.insert(dep.range[1], ")");
+	}
+};
+
+makeSerializable(
+	CreateScriptUrlDependency,
+	"webpack/lib/dependencies/CreateScriptUrlDependency"
+);
+
+module.exports = CreateScriptUrlDependency;

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -411,9 +411,8 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		const ignoredExports = new Set(["default", ...this.activeExports]);
 
 		let hiddenExports = undefined;
-		const otherStarExports = this._discoverActiveExportsFromOtherStarExports(
-			moduleGraph
-		);
+		const otherStarExports =
+			this._discoverActiveExportsFromOtherStarExports(moduleGraph);
 		if (otherStarExports !== undefined) {
 			hiddenExports = new Set();
 			for (let i = 0; i < otherStarExports.namesSlice; i++) {
@@ -441,9 +440,8 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				const name = exportInfo.name;
 				if (ignoredExports.has(name)) continue;
 				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				const importedExportInfo = importedExportsInfo.getReadOnlyExportInfo(
-					name
-				);
+				const importedExportInfo =
+					importedExportsInfo.getReadOnlyExportInfo(name);
 				if (importedExportInfo.provided === false) continue;
 				if (hiddenExports !== undefined && hiddenExports.has(name)) {
 					hidden.add(name);
@@ -763,9 +761,8 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 			`(reexported as '${this.name}')`
 		);
 		if (ids.length === 0 && this.name === null) {
-			const potentialConflicts = this._discoverActiveExportsFromOtherStarExports(
-				moduleGraph
-			);
+			const potentialConflicts =
+				this._discoverActiveExportsFromOtherStarExports(moduleGraph);
 			if (potentialConflicts && potentialConflicts.namesSlice > 0) {
 				const ownNames = new Set(
 					potentialConflicts.names.slice(
@@ -802,9 +799,8 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 							conflictingModule,
 							exportInfo.name
 						);
-						const conflictingTarget = conflictingExportInfo.getTerminalBinding(
-							moduleGraph
-						);
+						const conflictingTarget =
+							conflictingExportInfo.getTerminalBinding(moduleGraph);
 						if (!conflictingTarget) continue;
 						if (target === conflictingTarget) continue;
 						const list = conflicts.get(conflictingDependency.request);
@@ -882,7 +878,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 	apply(dependency, source, templateContext) {
 		const { moduleGraph, runtime, concatenationScope } = templateContext;
 
-		const dep = /** @type {HarmonyExportImportedSpecifierDependency} */ (dependency);
+		const dep = /** @type {HarmonyExportImportedSpecifierDependency} */ (
+			dependency
+		);
 
 		const mode = dep.getMode(moduleGraph, runtime);