webpack 5.21.0 → 5.23.0

package/lib/library/AssignLibraryPlugin.js

@@ -6,8 +6,10 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const { UsageState } = require("../ExportsInfo");
 const Template = require("../Template");
 const propertyAccess = require("../util/propertyAccess");
+const { getEntryRuntime } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -16,7 +18,9 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
@@ -93,11 +97,9 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
 /**
  * @typedef {Object} AssignLibraryPluginParsed
  * @property {string | string[]} name
+ * @property {string | string[] | undefined} export
  */
 
-const COMMON_LIBRARY_NAME_MESSAGE =
-	"Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
-
 /**
  * @typedef {AssignLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<AssignLibraryPluginParsed>}
@@ -126,69 +128,175 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 		if (this.unnamed === "error") {
 			if (typeof name !== "string" && !Array.isArray(name)) {
 				throw new Error(
-					`Library name must be a string or string array. ${COMMON_LIBRARY_NAME_MESSAGE}`
+					`Library name must be a string or string array. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
 				);
 			}
 		} else {
 			if (name && typeof name !== "string" && !Array.isArray(name)) {
 				throw new Error(
-					`Library name must be a string, string array or unset. ${COMMON_LIBRARY_NAME_MESSAGE}`
+					`Library name must be a string, string array or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
 				);
 			}
 		}
 		return {
-			name: /** @type {string|string[]=} */ (name)
+			name: /** @type {string|string[]=} */ (name),
+			export: library.export
 		};
 	}
 
 	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
 	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
+	 * @returns {void}
 	 */
-	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
-		const prefix =
-			this.prefix === "global"
-				? [compilation.outputOptions.globalObject]
-				: this.prefix;
+	finishEntryModule(
+		module,
+		entryName,
+		{ options, compilation, compilation: { moduleGraph } }
+	) {
+		const runtime = getEntryRuntime(compilation, entryName);
+		if (options.export) {
+			const exportsInfo = moduleGraph.getExportInfo(
+				module,
+				Array.isArray(options.export) ? options.export[0] : options.export
+			);
+			exportsInfo.setUsed(UsageState.Used, runtime);
+			exportsInfo.canMangleUse = false;
+		} else {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			exportsInfo.setUsedInUnknownWay(runtime);
+		}
+		moduleGraph.addExtraReason(module, "used as library export");
+	}
+
+	_getPrefix(compilation) {
+		return this.prefix === "global"
+			? [compilation.outputOptions.globalObject]
+			: this.prefix;
+	}
+
+	_getResolvedFullName(options, chunk, compilation) {
+		const prefix = this._getPrefix(compilation);
 		const fullName = options.name ? prefix.concat(options.name) : prefix;
-		const fullNameResolved = fullName.map(n =>
+		return fullName.map(n =>
 			compilation.getPath(n, {
 				chunk
 			})
 		);
-		const result = new ConcatSource();
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(source, { chunk }, { options, compilation }) {
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
 		if (this.declare) {
 			const base = fullNameResolved[0];
 			if (!isNameValid(base)) {
 				throw new Error(
 					`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template.toIdentifier(
 						base
-					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${COMMON_LIBRARY_NAME_MESSAGE}`
+					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${
+						AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE
+					}`
 				);
 			}
-			result.add(`${this.declare} ${base};`);
+			source = new ConcatSource(`${this.declare} ${base};\n`, source);
 		}
+		return source;
+	}
+
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	embedInRuntimeBailout(module, { chunk }, { options, compilation }) {
+		const topLevelDeclarations =
+			module.buildInfo && module.buildInfo.topLevelDeclarations;
+		if (!topLevelDeclarations)
+			return "it doesn't tell about top level declarations.";
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		const base = fullNameResolved[0];
+		if (topLevelDeclarations.has(base))
+			return `it declares '${base}' on top-level, which conflicts with the current library output.`;
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(source, module, { chunk }, { options, compilation }) {
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		const exportAccess = options.export
+			? propertyAccess(
+					Array.isArray(options.export) ? options.export : [options.export]
+			  )
+			: "";
+		const result = new ConcatSource(source);
 		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
 			result.add(
-				`(function(e, a) { for(var i in a) e[i] = a[i]; if(a.__esModule) Object.defineProperty(e, "__esModule", { value: true }); }(${accessWithInit(
+				`var __webpack_export_target__ = ${accessWithInit(
 					fullNameResolved,
-					prefix.length,
+					this._getPrefix(compilation).length,
 					true
-				)},\n`
+				)};\n`
+			);
+			let exports = "__webpack_exports__";
+			if (exportAccess) {
+				result.add(
+					`var __webpack_exports_export__ = __webpack_exports__${exportAccess};\n`
+				);
+				exports = "__webpack_exports_export__";
+			}
+			result.add(
+				`for(var i in ${exports}) __webpack_export_target__[i] = ${exports}[i];\n`
+			);
+			result.add(
+				`if(${exports}.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });\n`
 			);
-			result.add(source);
-			result.add("\n))");
 		} else {
 			result.add(
-				`${accessWithInit(fullNameResolved, prefix.length, false)} =\n`
+				`${accessWithInit(
+					fullNameResolved,
+					this._getPrefix(compilation).length,
+					false
+				)} = __webpack_exports__${exportAccess};\n`
 			);
-			result.add(source);
 		}
 		return result;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	runtimeRequirements(chunk, set, libraryContext) {
+		// we don't need to return exports from runtime
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {Hash} hash hash
@@ -208,13 +316,16 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 				chunk
 			})
 		);
-		if (!options.name && this.unnamed === "copy") {
+		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
 			hash.update("copy");
 		}
 		if (this.declare) {
 			hash.update(this.declare);
 		}
 		hash.update(fullNameResolved.join("."));
+		if (options.export) {
+			hash.update(`${options.export}`);
+		}
 	}
 }
 

package/lib/library/EnableLibraryPlugin.js

@@ -70,11 +70,13 @@ class EnableLibraryPlugin {
 		enabled.add(type);
 
 		if (typeof type === "string") {
-			const ExportPropertyTemplatePlugin = require("./ExportPropertyLibraryPlugin");
-			new ExportPropertyTemplatePlugin({
-				type,
-				nsObjectUsed: type !== "module"
-			}).apply(compiler);
+			const enableExportProperty = () => {
+				const ExportPropertyTemplatePlugin = require("./ExportPropertyLibraryPlugin");
+				new ExportPropertyTemplatePlugin({
+					type,
+					nsObjectUsed: type !== "module"
+				}).apply(compiler);
+			};
 			switch (type) {
 				case "var": {
 					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
@@ -179,6 +181,7 @@ class EnableLibraryPlugin {
 				}
 				case "amd":
 				case "amd-require": {
+					enableExportProperty();
 					const AmdLibraryPlugin = require("./AmdLibraryPlugin");
 					new AmdLibraryPlugin({
 						type,
@@ -188,6 +191,7 @@ class EnableLibraryPlugin {
 				}
 				case "umd":
 				case "umd2": {
+					enableExportProperty();
 					const UmdLibraryPlugin = require("./UmdLibraryPlugin");
 					new UmdLibraryPlugin({
 						type,
@@ -196,6 +200,7 @@ class EnableLibraryPlugin {
 					break;
 				}
 				case "system": {
+					enableExportProperty();
 					const SystemLibraryPlugin = require("./SystemLibraryPlugin");
 					new SystemLibraryPlugin({
 						type
@@ -203,15 +208,21 @@ class EnableLibraryPlugin {
 					break;
 				}
 				case "jsonp": {
+					enableExportProperty();
 					const JsonpLibraryPlugin = require("./JsonpLibraryPlugin");
 					new JsonpLibraryPlugin({
 						type
 					}).apply(compiler);
 					break;
 				}
-				case "module":
-					// TODO implement module library
+				case "module": {
+					enableExportProperty();
+					const ModuleLibraryPlugin = require("./ModuleLibraryPlugin");
+					new ModuleLibraryPlugin({
+						type
+					}).apply(compiler);
 					break;
+				}
 				default:
 					throw new Error(`Unsupported library type ${type}.
 Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -14,9 +14,10 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
@@ -84,17 +85,27 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 		}
 		moduleGraph.addExtraReason(module, "used as library export");
 	}
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	runtimeRequirements(chunk, set, libraryContext) {}
+
 	/**
 	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {Source} source with library export
 	 */
-	render(source, renderContext, { options }) {
+	renderStartup(source, module, renderContext, { options }) {
 		if (!options.export) return source;
-		const postfix = propertyAccess(
+		const postfix = `__webpack_exports__ = __webpack_exports__${propertyAccess(
 			Array.isArray(options.export) ? options.export : [options.export]
-		);
+		)};\n`;
 		return new ConcatSource(source, postfix);
 	}
 }

package/lib/library/JsonpLibraryPlugin.js

@@ -50,7 +50,9 @@ class JsonpLibraryPlugin extends AbstractLibraryPlugin {
 	parseOptions(library) {
 		const { name } = library;
 		if (typeof name !== "string") {
-			throw new Error("Jsonp library name must be a simple string");
+			throw new Error(
+				`Jsonp library name must be a simple string. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
 		}
 		return {
 			name: /** @type {string} */ (name)

package/lib/library/ModuleLibraryPlugin.js

@@ -0,0 +1,100 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { ConcatSource } = require("webpack-sources");
+const Template = require("../Template");
+const propertyAccess = require("../util/propertyAccess");
+const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @typedef {Object} ModuleLibraryPluginOptions
+ * @property {LibraryType} type
+ */
+
+/**
+ * @typedef {Object} ModuleLibraryPluginParsed
+ * @property {string} name
+ */
+
+/**
+ * @typedef {ModuleLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
+ */
+class ModuleLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {ModuleLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "ModuleLibraryPlugin",
+			type: options.type
+		});
+	}
+
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (name) {
+			throw new Error(
+				`Library name must unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
+		}
+		return {
+			name: /** @type {string} */ (name)
+		};
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
+		const result = new ConcatSource(source);
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		const exports = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			if (!exportInfo.provided) continue;
+			const varName = `__webpack_exports__${Template.toIdentifier(
+				exportInfo.name
+			)}`;
+			result.add(
+				`var ${varName} = __webpack_exports__${propertyAccess([
+					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
+				])};\n`
+			);
+			exports.push(`${varName} as ${exportInfo.name}`);
+		}
+		if (exports.length > 0) {
+			result.add(`export { ${exports.join(", ")} };\n`);
+		}
+		return result;
+	}
+}
+
+module.exports = ModuleLibraryPlugin;

package/lib/library/SystemLibraryPlugin.js

@@ -55,7 +55,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 		const { name } = library;
 		if (name && typeof name !== "string") {
 			throw new Error(
-				"System.js library name must be a simple string or unset"
+				`System.js library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
 			);
 		}
 		return {

package/lib/node/NodeTargetPlugin.js

@@ -52,7 +52,7 @@ const builtins = [
 	"util",
 	"v8",
 	"vm",
-	"wasi", // cSpell:ignore wasi
+	"wasi",
 	"worker_threads",
 	"zlib"
 ];

package/lib/optimize/ConcatenatedModule.js

@@ -133,41 +133,43 @@ const {
  * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
  */
 
-const RESERVED_NAMES = [
-	// internal names (should always be renamed)
-	ConcatenationScope.DEFAULT_EXPORT,
-	ConcatenationScope.NAMESPACE_OBJECT_EXPORT,
-
-	// keywords
-	"abstract,arguments,async,await,boolean,break,byte,case,catch,char,class,const,continue",
-	"debugger,default,delete,do,double,else,enum,eval,export,extends,false,final,finally,float",
-	"for,function,goto,if,implements,import,in,instanceof,int,interface,let,long,native,new,null",
-	"package,private,protected,public,return,short,static,super,switch,synchronized,this,throw",
-	"throws,transient,true,try,typeof,var,void,volatile,while,with,yield",
-
-	// commonjs
-	"module,__dirname,__filename,exports",
-
-	// js globals
-	"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
-	"NaN,name,Number,Object,prototype,String,toString,undefined,valueOf",
-
-	// browser globals
-	"alert,all,anchor,anchors,area,assign,blur,button,checkbox,clearInterval,clearTimeout",
-	"clientInformation,close,closed,confirm,constructor,crypto,decodeURI,decodeURIComponent",
-	"defaultStatus,document,element,elements,embed,embeds,encodeURI,encodeURIComponent,escape",
-	"event,fileUpload,focus,form,forms,frame,innerHeight,innerWidth,layer,layers,link,location",
-	"mimeTypes,navigate,navigator,frames,frameRate,hidden,history,image,images,offscreenBuffering",
-	"open,opener,option,outerHeight,outerWidth,packages,pageXOffset,pageYOffset,parent,parseFloat",
-	"parseInt,password,pkcs11,plugin,prompt,propertyIsEnum,radio,reset,screenX,screenY,scroll",
-	"secure,select,self,setInterval,setTimeout,status,submit,taint,text,textarea,top,unescape",
-	"untaint,window",
-
-	// window events
-	"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
-]
-	.join(",")
-	.split(",");
+const RESERVED_NAMES = new Set(
+	[
+		// internal names (should always be renamed)
+		ConcatenationScope.DEFAULT_EXPORT,
+		ConcatenationScope.NAMESPACE_OBJECT_EXPORT,
+
+		// keywords
+		"abstract,arguments,async,await,boolean,break,byte,case,catch,char,class,const,continue",
+		"debugger,default,delete,do,double,else,enum,eval,export,extends,false,final,finally,float",
+		"for,function,goto,if,implements,import,in,instanceof,int,interface,let,long,native,new,null",
+		"package,private,protected,public,return,short,static,super,switch,synchronized,this,throw",
+		"throws,transient,true,try,typeof,var,void,volatile,while,with,yield",
+
+		// commonjs/amd
+		"module,__dirname,__filename,exports,require,define",
+
+		// js globals
+		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
+		"NaN,name,Number,Object,prototype,String,toString,undefined,valueOf",
+
+		// browser globals
+		"alert,all,anchor,anchors,area,assign,blur,button,checkbox,clearInterval,clearTimeout",
+		"clientInformation,close,closed,confirm,constructor,crypto,decodeURI,decodeURIComponent",
+		"defaultStatus,document,element,elements,embed,embeds,encodeURI,encodeURIComponent,escape",
+		"event,fileUpload,focus,form,forms,frame,innerHeight,innerWidth,layer,layers,link,location",
+		"mimeTypes,navigate,navigator,frames,frameRate,hidden,history,image,images,offscreenBuffering",
+		"open,opener,option,outerHeight,outerWidth,packages,pageXOffset,pageYOffset,parent,parseFloat",
+		"parseInt,password,pkcs11,plugin,prompt,propertyIsEnum,radio,reset,screenX,screenY,scroll",
+		"secure,select,self,setInterval,setTimeout,status,submit,taint,text,textarea,top,unescape",
+		"untaint,window",
+
+		// window events
+		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
+	]
+		.join(",")
+		.split(",")
+);
 
 const bySourceOrder = (a, b) => {
 	const aOrder = a.sourceOrder;
@@ -761,6 +763,7 @@ class ConcatenatedModule extends Module {
 			fileDependencies: new LazySet(),
 			contextDependencies: new LazySet(),
 			missingDependencies: new LazySet(),
+			topLevelDeclarations: new Set(),
 			assets: undefined
 		};
 		this.buildMeta = rootModule.buildMeta;
@@ -802,6 +805,22 @@ class ConcatenatedModule extends Module {
 				}
 			}
 
+			// populate topLevelDeclarations
+			if (m.buildInfo.topLevelDeclarations) {
+				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
+				if (topLevelDeclarations !== undefined) {
+					for (const decl of m.buildInfo.topLevelDeclarations) {
+						// reserved names will always be renamed
+						if (RESERVED_NAMES.has(decl)) continue;
+						// TODO actually this is incorrect since with renaming there could be more
+						// We should do the renaming during build
+						topLevelDeclarations.add(decl);
+					}
+				}
+			} else {
+				this.buildInfo.topLevelDeclarations = undefined;
+			}
+
 			// populate assets
 			if (m.buildInfo.assets) {
 				if (this.buildInfo.assets === undefined) {

package/lib/optimize/InnerGraph.js

@@ -102,10 +102,11 @@ exports.addUsage = (state, symbol, usage) => {
  * @returns {void}
  */
 exports.addVariableUsage = (parser, name, usage) => {
-	const symbol = /** @type {TopLevelSymbol} */ (parser.getTagData(
-		name,
-		topLevelSymbolTag
-	));
+	const symbol =
+		/** @type {TopLevelSymbol} */ (parser.getTagData(
+			name,
+			topLevelSymbolTag
+		)) || exports.tagTopLevelSymbol(parser, name);
 	if (symbol) {
 		exports.addUsage(parser.state, symbol, usage);
 	}

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -7,6 +7,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { first } = require("../util/SetHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
@@ -259,9 +260,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 								Array.from(staticUrls, ([url, ids]) => {
 									const condition =
 										ids.size === 1
-											? `chunkId === ${JSON.stringify(
-													ids.values().next().value
-											  )}`
+											? `chunkId === ${JSON.stringify(first(ids))}`
 											: `{${Array.from(
 													ids,
 													id => `${JSON.stringify(id)}:1`